Spaces:

ginigen
/

GINI-Deck

Running

App Files Files Community

ginipick commited on 17 days ago

Commit

37e200d

verified ·

1 Parent(s): 2de4d6d

Update app.py

Browse files

Files changed (1) hide show

app.py +23 -2254

app.py CHANGED Viewed

@@ -1,2266 +1,35 @@
-import replicate
-import requests
 import os
-import json
-from io import BytesIO
-from PIL import Image
-from typing import List, Tuple, Dict
-from datetime import datetime
-import time
-import traceback
-import base64
-from pptx import Presentation
-from pptx.util import Inches, Pt
-from pptx.dml.color import RGBColor
-from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
-from pptx.enum.shapes import MSO_SHAPE
-import PyPDF2
-import pandas as pd
-import chardet
-import gradio as gr
-# 프로세스 플로우 생성기 임포트 추가
-try:
-    from process_flow_generator import generate_process_flow_for_ppt
-    PROCESS_FLOW_AVAILABLE = True
-except ImportError:
-    PROCESS_FLOW_AVAILABLE = False
-    print("[경고] process_flow_generator를 임포트할 수 없습니다. 프로세스 플로우 다이어그램 기능이 비활성화됩니다.")
-# 예제 템플릿 정의
-EXAMPLE_TOPICS = {
-    "비즈니스 제안서": "AI 기반 고객 서비스 자동화 플랫폼 투자 제안",
-    "제품 소개": "스마트 홈 IoT 보안 시스템 신제품 런칭",
-    "프로젝트 보고": "디지털 전환 프로젝트 3분기 성과 보고",
-    "전략 기획": "2025년 글로벌 시장 진출 전략 수립"
-}
-# 오디언스 타입 정의
-AUDIENCE_TYPES = {
-    "경영진/임원": {
-        "description": "C-level, 의사결정권자",
-        "tone": "전략적, 결과 중심, ROI 강조",
-        "focus": "비즈니스 가치, 투자 수익률, 전략적 영향"
-    },
-    "투자자": {
-        "description": "VC, 엔젤투자자, 기관투자자",
-        "tone": "수치 기반, 성장 가능성, 시장 기회",
-        "focus": "시장 규모, 성장률, 경쟁우위, Exit 전략"
-    },
-    "기술팀": {
-        "description": "개발자, 엔지니어, IT 전문가",
-        "tone": "기술적, 구체적, 실용적",
-        "focus": "기술 스택, 아키텍처, 구현 방법, 성능"
-    },
-    "일반 직원": {
-        "description": "실무자, 팀원",
-        "tone": "친근한, 실무적, 협업 중심",
-        "focus": "실행 계획, 역할, 프로세스, 협업 방안"
-    },
-    "고객/파트너": {
-        "description": "B2B 고객, 비즈니스 파트너",
-        "tone": "신뢰감, 전문적, 혜택 중심",
-        "focus": "고객 가치, 혜택, 사례, 지원 체계"
-    },
-    "일반 대중": {
-        "description": "B2C 고객, 일반 사용자",
-        "tone": "쉽고 친근한, 이해하기 쉬운",
-        "focus": "사용 편의성, 혜택, 가격, 차별점"
-    }
-}
-# 환경 변수에서 토큰 가져오기
-REPLICATE_API_TOKEN = os.getenv("RAPI_TOKEN")
-FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN")
-BRAVE_API_TOKEN = os.getenv("BAPI_TOKEN")
-# 전역 변수로 현재 슬라이드 데이터 저장
-current_slides_data = []
-current_topic = ""
-current_template = ""
-current_theme = ""
-uploaded_content = ""  # 전역 변수로 추가
-# 디자인 테마 정의
-DESIGN_THEMES = {
-    "미니멀 라이트": {
-        "name": "Minimal Light",
-        "description": "밝고 깨끗한 미니멀 디자인",
-        "background": RGBColor(250, 250, 252),
-        "title_color": RGBColor(33, 37, 41),
-        "subtitle_color": RGBColor(52, 58, 64),
-        "text_color": RGBColor(73, 80, 87),
-        "accent_color": RGBColor(0, 123, 255),
-        "box_fill": RGBColor(255, 255, 255),
-        "box_opacity": 0.95,
-        "shadow": True,
-        "gradient": False
-    },
-    "모던 그라디언트": {
-        "name": "Modern Gradient",
-        "description": "부드러운 그라디언트와 현대적 느낌",
-        "background": RGBColor(245, 247, 250),
-        "title_color": RGBColor(25, 42, 86),
-        "subtitle_color": RGBColor(68, 85, 102),
-        "text_color": RGBColor(85, 102, 119),
-        "accent_color": RGBColor(103, 58, 183),
-        "box_fill": RGBColor(249, 250, 251),
-        "box_opacity": 0.9,
-        "shadow": True,
-        "gradient": True
-    },
-    "다크 엘레강스": {
-        "name": "Dark Elegance",
-        "description": "세련된 다크 모드 디자인",
-        "background": RGBColor(25, 25, 35),
-        "title_color": RGBColor(240, 240, 245),
-        "subtitle_color": RGBColor(200, 200, 210),
-        "text_color": RGBColor(170, 170, 180),
-        "accent_color": RGBColor(0, 188, 212),
-        "box_fill": RGBColor(35, 35, 45),
-        "box_opacity": 0.85,
-        "shadow": False,
-        "gradient": False
-    },
-    "네이처 그린": {
-        "name": "Nature Green",
-        "description": "자연 친화적인 그린 테마",
-        "background": RGBColor(242, 248, 244),
-        "title_color": RGBColor(27, 67, 50),
-        "subtitle_color": RGBColor(45, 106, 79),
-        "text_color": RGBColor(64, 125, 98),
-        "accent_color": RGBColor(76, 175, 80),
-        "box_fill": RGBColor(255, 255, 255),
-        "box_opacity": 0.92,
-        "shadow": True,
-        "gradient": False
-    },
-    "코퍼레이트 블루": {
-        "name": "Corporate Blue",
-        "description": "전문적인 비즈니스 스타일",
-        "background": RGBColor(244, 247, 252),
-        "title_color": RGBColor(13, 71, 161),
-        "subtitle_color": RGBColor(25, 118, 210),
-        "text_color": RGBColor(42, 63, 84),
-        "accent_color": RGBColor(33, 150, 243),
-        "box_fill": RGBColor(255, 255, 255),
-        "box_opacity": 0.95,
-        "shadow": True,
-        "gradient": False
-    }
-}
-# 스타일 정의 (프로세스 플로우 추가)
-STYLE_TEMPLATES = {
-    "Title Slide (Hero)": {
-        "name": "Title Slide",
-        "description": "Impactful hero image for title slide",
-        "use_case": "표지, 타이틀",
-        "example": "A dramatic wide-angle view of a modern glass skyscraper reaching into clouds with golden sunset lighting, symbolizing growth and ambition. Ultra-realistic photography style, cinematic composition, lens flare, professional corporate aesthetic"
-    },
-    "Thank You Slide": {
-        "name": "Closing Slide",
-        "description": "Elegant closing slide design with conclusion",
-        "use_case": "프레젠테이션 마무리",
-        "example": "Abstract elegant background with soft gradient from deep blue to purple, golden particles floating like celebration confetti, subtle light rays, with space for conclusion text. Minimalist, professional, warm feeling"
-    },
-    "3D Style (Pixar-like)": {
-        "name": "3D Style",
-        "description": "Pixar-esque 3D render with volumetric lighting",
-        "use_case": "표지, 비전, 미래 컨셉",
-        "example": "A fluffy ginger cat wearing a tiny spacesuit, floating amidst a vibrant nebula in a 3D render. The cat is gazing curiously at a swirling planet with rings made of candy. Background is filled with sparkling stars and colorful gas clouds, lit with soft, volumetric lighting. Style: Pixar-esque, highly detailed, playful. Colors: Deep blues, purples, oranges, and pinks. Rendered in Octane, 8k resolution."
-    },
-    "Elegant SWOT Quadrant": {
-        "name": "SWOT Analysis",
-        "description": "Flat-design 4-grid layout with minimal shadows",
-        "use_case": "현황 분석, 전략 평가",
-        "example": "Elegant SWOT quadrant: flat-design 4-grid on matte-white backdrop, thin pastel separators, top-left 'Strengths' panel shows glowing shield icon and subtle motif, top-right 'Weaknesses' panel with cracked chain icon in soft crimson, bottom-left 'Opportunities' panel with sunrise-over-horizon icon in optimistic teal, bottom-right 'Threats' panel with storm-cloud & lightning icon in deep indigo, minimal shadows, no text, no watermark, 16:9, 4K"
-    },
-    "Colorful Mind Map": {
-        "name": "Mind Map",
-        "description": "Hand-drawn educational style with vibrant colors",
-        "use_case": "브레인스토밍, 아이디어 정리",
-        "example": "A handrawn colorful mind map diagram: educational style, vibrant colors, clear hierarchy, golden ratio layout. Central concept with branching sub-topics, each branch with unique color coding, organic flowing connections, doodle-style icons for each node"
-    },
-    "Business Workflow": {
-        "name": "Business Process",
-        "description": "End-to-end business workflow with clear phases",
-        "use_case": "프로세스 설명, 단계별 진행",
-        "example": "A detailed hand-drawn diagram illustrating an end-to-end business workflow with Market Analysis, Strategy Development, Product Design, Implementation, and Post-Launch Review phases. Clear directional arrows, iconography for each component, vibrant educational yet professional style",
-        "is_process_flow": True  # 프로세스 플로우 다이어그램 사용 표시
-    },
-    "Industrial Design": {
-        "name": "Product Design",
-        "description": "Sleek industrial design concept sketch",
-        "use_case": "제품 소개, 컨셉 디자인",
-        "example": "A sleek industrial design concept: Curved metallic body with minimal bezel, Touchscreen panel for settings, Modern matte black finish, Hand-drawn concept sketch style with annotations and dimension lines"
-    },
-    "3D Bubble Chart": {
-        "name": "Bubble Chart",
-        "description": "Clean 3D bubble visualization",
-        "use_case": "비교 분석, 포지셔닝",
-        "example": "3-D bubble chart on clean white 2×2 grid, quadrant titles hidden, four translucent spheres in lime, azure, amber, magenta, gentle depth-of-field, modern consulting aesthetic, no text, 4K"
-    },
-    "Timeline Ribbon": {
-        "name": "Timeline",
-        "description": "Horizontal ribbon timeline with cyber-futuristic vibe",
-        "use_case": "일정, 로드맵, 마일스톤",
-        "example": "Horizontal ribbon timeline, milestone pins glowing hot pink on charcoal, year markers as circles, faint motion streaks, cyber-futuristic vibe, no text, 1920×1080"
-    },
-    "Risk Heat Map": {
-        "name": "Heat Map",
-        "description": "Risk assessment heat map with gradient colors",
-        "use_case": "리스크 분석, 우선순위",
-        "example": "Risk Heat Map: square grid, smooth gradient from mint to fire-red, cells beveled, simple legend strip hidden, long subtle shadow, sterile white frame, no text"
-    },
-    "Pyramid/Funnel": {
-        "name": "Funnel Chart",
-        "description": "Multi-layer gradient funnel visualization",
-        "use_case": "단계별 축소, 핵심 도출",
-        "example": "Pyramid / Funnel: 5-layer gradient funnel narrowing downwards, top vivid sky-blue, mid mint-green, bottom sunset-orange, glass reflection, minimal background, no text"
-    },
-    "KPI Dashboard": {
-        "name": "Dashboard",
-        "description": "Dark-mode analytics dashboard with sci-fi interface",
-        "use_case": "성과 지표, 실적 대시보드",
-        "example": "KPI Dashboard: Dark-mode analytic dashboard, three glass speedometers glowing neon lime, two sparkline charts under, black glass background, sci-fi interface, no text, 4K"
-    },
-    "Value Chain": {
-        "name": "Value Chain",
-        "description": "Horizontal value chain with industrial look",
-        "use_case": "가치 사슬, 비즈니스 모델",
-        "example": "Value Chain Diagram: Horizontal value chain blocks, steel-blue gradient bars with subtle bevel, small gear icons above each segment, sleek industrial look, shadow cast, no text"
-    },
-    "Gantt Chart": {
-        "name": "Gantt Chart",
-        "description": "Hand-drawn style Gantt chart with playful colors",
-        "use_case": "프로젝트 일정, 작업 관리",
-        "example": "Gantt Chart: Hand-drawn style Gantt bars sketched with vibrant markers on dotted grid notebook page, sticky-note color palette, playful yet organized, perspective tilt, no text"
-    },
-    "Mobile App Mockup": {
-        "name": "App Mockup",
-        "description": "Clean wireframe for mobile app design",
-        "use_case": "앱/웹 UI, 화면 설계",
-        "example": "MOCKUP DESIGN: A clean hand-drawn style wireframe for a mobile app with Title screen, Login screen, Dashboard with sections, Bottom navigation bar, minimalist design with annotations"
-    },
-    "Flowchart": {
-        "name": "Flowchart",
-        "description": "Vibrant flowchart with minimalistic icons",
-        "use_case": "의사결정, 프로세스 흐름",
-        "example": "FLOWCHART DESIGN: A hand-drawn style flowchart, vibrant colors, minimalistic icons showing process flow from START to END with decision points, branches, and clear directional arrows",
-        "is_process_flow": True  # 프로세스 플로우 다이어그램 사용 표시
-    }
-}
-# PPT 템플릿 정의 (동적으로 슬라이드 수 조정 가능)
-# PPT_TEMPLATES 수정 - 프로세스 플로우는 특정 슬라이드에만 적용
-PPT_TEMPLATES = {
-    "비즈니스 제안서": {
-        "description": "투자 유치, 사업 제안용",
-        "core_slides": [
-            {"title": "목차", "style": "Flowchart", "prompt_hint": "프레젠테이션 구조"},  # 이건 목차용 플로우차트
-            {"title": "문제 정의", "style": "Colorful Mind Map", "prompt_hint": "현재 시장의 문제점"},
-            {"title": "현황 분석", "style": "Elegant SWOT Quadrant", "prompt_hint": "강점, 약점, 기회, 위협"},
-            {"title": "솔루션", "style": "Industrial Design", "prompt_hint": "제품/서비스 컨셉"},
-            {"title": "프로세스", "style": "Business Workflow", "prompt_hint": "실행 단계"},  # 여기서만 프로세스 플로우
-            {"title": "일정", "style": "Timeline Ribbon", "prompt_hint": "주요 마일스톤"}
-        ],
-        "optional_slides": [
-            {"title": "시장 규모", "style": "3D Bubble Chart", "prompt_hint": "시장 기회와 성장성"},
-            {"title": "경쟁 분석", "style": "Risk Heat Map", "prompt_hint": "경쟁사 포지셔닝"},
-            {"title": "비즈니스 모델", "style": "Value Chain", "prompt_hint": "수익 구조"},
-            {"title": "팀 소개", "style": "Colorful Mind Map", "prompt_hint": "핵심 팀원과 역량"},
-            {"title": "재무 계획", "style": "KPI Dashboard", "prompt_hint": "예상 매출과 손익"},
-            {"title": "위험 관리", "style": "Risk Heat Map", "prompt_hint": "주요 리스크와 대응"},
-            {"title": "파트너십", "style": "Value Chain", "prompt_hint": "전략적 제휴"},  # Business Workflow 대신 Value Chain
-            {"title": "기술 스택", "style": "Industrial Design", "prompt_hint": "핵심 기술 구조"},  # Flowchart 대신
-            {"title": "고객 사례", "style": "Industrial Design", "prompt_hint": "성공 사례"},
-            {"title": "성장 전략", "style": "Timeline Ribbon", "prompt_hint": "확장 계획"},
-            {"title": "투자 활용", "style": "Pyramid/Funnel", "prompt_hint": "자금 사용 계획"},
-            {"title": "Exit 전략", "style": "Timeline Ribbon", "prompt_hint": "출구 전략"}
-        ]
-    },
-    "제품 소개": {
-        "description": "신제품 런칭, 서비스 소개용",
-        "core_slides": [
-            {"title": "제품 컨셉", "style": "Industrial Design", "prompt_hint": "제품 디자인"},
-            {"title": "사용자 니즈", "style": "Colorful Mind Map", "prompt_hint": "고객 페인포인트"},
-            {"title": "기능 소개", "style": "Mobile App Mockup", "prompt_hint": "UI/UX 화면"},
-            {"title": "작동 원리", "style": "Flowchart", "prompt_hint": "기능 플로우"},  # 여기서만 프로세스 플로우
-            {"title": "시장 포지션", "style": "3D Bubble Chart", "prompt_hint": "경쟁사 비교"},
-            {"title": "출시 일정", "style": "Timeline Ribbon", "prompt_hint": "런칭 로드맵"}
-        ],
-        "optional_slides": [
-            {"title": "타겟 고객", "style": "Colorful Mind Map", "prompt_hint": "주요 고객층"},
-            {"title": "가격 정책", "style": "Pyramid/Funnel", "prompt_hint": "가격 전략"},
-            {"title": "기술 우위", "style": "Industrial Design", "prompt_hint": "핵심 기술"},
-            {"title": "사용 시나리오", "style": "Mobile App Mockup", "prompt_hint": "활용 사례"},  # Business Workflow 대신
-            {"title": "고객 후기", "style": "KPI Dashboard", "prompt_hint": "사용자 평가"},
-            {"title": "판매 채널", "style": "Value Chain", "prompt_hint": "유통 전략"},
-            {"title": "마케팅 전략", "style": "Timeline Ribbon", "prompt_hint": "홍보 계획"},
-            {"title": "성능 비교", "style": "3D Bubble Chart", "prompt_hint": "벤치마크"}
-        ]
-    },
-    "프로젝트 보고": {
-        "description": "진행 상황, 성과 보고용",
-        "core_slides": [
-            {"title": "프로젝트 개요", "style": "Business Workflow", "prompt_hint": "전체 프로세스"},  # 여기서만
-            {"title": "진행 현황", "style": "Gantt Chart", "prompt_hint": "작업 일정"},
-            {"title": "리스크 관리", "style": "Risk Heat Map", "prompt_hint": "위험 요소"},
-            {"title": "성과 지표", "style": "KPI Dashboard", "prompt_hint": "달성 실적"},
-            {"title": "향후 계획", "style": "Timeline Ribbon", "prompt_hint": "다음 단계"}
-        ],
-        "optional_slides": [
-            {"title": "예산 현황", "style": "Pyramid/Funnel", "prompt_hint": "예산 집행"},
-            {"title": "팀 성과", "style": "3D Bubble Chart", "prompt_hint": "팀별 기여도"},
-            {"title": "이슈 관리", "style": "Risk Heat Map", "prompt_hint": "주요 이슈"},
-            {"title": "개선 사항", "style": "Colorful Mind Map", "prompt_hint": "프로세스 개선"},
-            {"title": "교훈", "style": "Colorful Mind Map", "prompt_hint": "배운 점"}  # Business Workflow 대신
-        ]
-    },
-    "전략 기획": {
-        "description": "중장기 전략, 비전 수립용",
-        "core_slides": [
-            {"title": "비전", "style": "3D Style (Pixar-like)", "prompt_hint": "미래 비전"},
-            {"title": "환경 분석", "style": "Elegant SWOT Quadrant", "prompt_hint": "내외부 환경"},
-            {"title": "전략 체계", "style": "Colorful Mind Map", "prompt_hint": "전략 구조"},
-            {"title": "가치 사슬", "style": "Value Chain", "prompt_hint": "비즈니스 모델"},
-            {"title": "실행 로드맵", "style": "Timeline Ribbon", "prompt_hint": "단계별 계획"},
-            {"title": "목표 지표", "style": "KPI Dashboard", "prompt_hint": "KPI 목표"}
-        ],
-        "optional_slides": [
-            {"title": "시장 전망", "style": "3D Bubble Chart", "prompt_hint": "미래 시장"},
-            {"title": "혁신 방향", "style": "Industrial Design", "prompt_hint": "혁신 전략"},
-            {"title": "조직 변화", "style": "Value Chain", "prompt_hint": "조직 개편"},  # Business Workflow 대신
-            {"title": "디지털 전환", "style": "Industrial Design", "prompt_hint": "DX 전략"},  # Flowchart 대신
-            {"title": "지속가능성", "style": "Timeline Ribbon", "prompt_hint": "ESG 전략"}
-        ]
-    },
-    "사용자 정의": {
-        "description": "직접 구성하기",
-        "core_slides": [],
-        "optional_slides": []
-    }
-}
-def brave_search(query: str) -> List[Dict]:
-    """Brave Search API를 사용한 웹 검색"""
-    if not BRAVE_API_TOKEN:
-        print("[Brave Search] API 토큰이 없어 검색을 건너뜁니다.")
-        return []
-    print(f"[Brave Search] 검색어: {query}")
-    headers = {
-        "Accept": "application/json",
-        "X-Subscription-Token": BRAVE_API_TOKEN
-    }
-    params = {
-        "q": query,
-        "count": 5
-    }
-    try:
-        response = requests.get(
-            "https://api.search.brave.com/res/v1/web/search",
-            headers=headers,
-            params=params,
-            timeout=10
-        )
-        if response.status_code == 200:
-            data = response.json()
-            results = []
-            for item in data.get("web", {}).get("results", [])[:3]:
-                results.append({
-                    "title": item.get("title", ""),
-                    "description": item.get("description", ""),
-                    "url": item.get("url", "")
-                })
-            print(f"[Brave Search] {len(results)}개 결과 획득")
-            return results
-        else:
-            print(f"[Brave Search] 오류: {response.status_code}")
-            return []
-    except Exception as e:
-        print(f"[Brave Search] 예외: {str(e)}")
-        return []
-def read_uploaded_file(file_path: str) -> str:
-    """업로드된 파일 읽기 (PDF, CSV, TXT)"""
-    print(f"[파일 읽기] {file_path}")
-    try:
-        # 파일 확장자 확인
-        ext = os.path.splitext(file_path)[1].lower()
-        if ext == '.pdf':
-            # PDF 읽기
-            with open(file_path, 'rb') as file:
-                pdf_reader = PyPDF2.PdfReader(file)
-                text = ""
-                for page in pdf_reader.pages:
-                    text += page.extract_text() + "\n"
-                return text[:5000]  # 최대 5000자
-        elif ext == '.csv':
-            # CSV 읽기
-            # 인코딩 감지
-            with open(file_path, 'rb') as file:
-                raw_data = file.read()
-                result = chardet.detect(raw_data)
-                encoding = result['encoding'] or 'utf-8'
-            df = pd.read_csv(file_path, encoding=encoding)
-            return f"CSV 데이터:\n{df.head(20).to_string()}\n\n요약: {len(df)} 행, {len(df.columns)} 열"
-        elif ext in ['.txt', '.text']:
-            # 텍스트 파일 읽기
-            with open(file_path, 'rb') as file:
-                raw_data = file.read()
-                result = chardet.detect(raw_data)
-                encoding = result['encoding'] or 'utf-8'
-            with open(file_path, 'r', encoding=encoding) as file:
-                return file.read()[:5000]  # 최대 5000자
-        else:
-            return "지원하지 않는 파일 형식입니다."
-    except Exception as e:
-        return f"파일 읽기 오류: {str(e)}"
-def generate_presentation_notes(topic: str, slide_title: str, content: Dict, audience_type: str) -> str:
-    """각 슬라이드의 발표자 노트 생성 (구어체)"""
-    print(f"[발표자 노트] {slide_title} 생성 중...")
-    # 오디언스 정보 가져오기
-    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    system_prompt = f"""You are a professional presentation coach who creates natural, conversational speaker notes.
-The audience for this presentation is: {audience_type} - {audience_info['description']}
-Tone: {audience_info['tone']}
-Focus areas: {audience_info['focus']}
-The slide content uses concise noun-ending style, but your speaker notes should be natural and conversational.
-Create speaker notes that:
-1. Sound natural and conversational, as if speaking to {audience_type}
-2. Expand on the concise bullet points with additional context relevant to this audience
-3. Include transitions and engagement phrases appropriate for {audience_type}
-4. Use a warm, professional tone suitable for {audience_type}
-5. Be 100-150 words long
-6. Include pauses and emphasis markers where appropriate
-Note: The bullet points may include emojis - incorporate their meaning into your speech.
-Format:
-- Use conversational language appropriate for {audience_type}
-- Include transition phrases
-- Add engagement questions or comments that resonate with this audience
-- Keep it professional but friendly"""
-    bullet_text = "\n".join(content.get("bullet_points", []))
-    user_message = f"""Topic: {topic}
-Slide Title: {slide_title}
-Subtitle: {content.get('subtitle', '')}
-Key Points (concise style with emojis):
-{bullet_text}
-Create natural speaker notes that expand on these concise points for presenting this slide to {audience_type}."""
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": system_prompt
-            },
-            {
-                "role": "user",
-                "content": user_message
-            }
-        ],
-        "max_tokens": 300,
-        "temperature": 0.8,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            notes = result['choices'][0]['message']['content'].strip()
-            # 한글 주제인 경우 번��
-            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
-                notes = translate_content_to_korean_natural(notes)
-            return notes
-        else:
-            return "이 슬라이드에서는 핵심 내용을 설명해 주세요."
-    except Exception as e:
-        print(f"[발표자 노트] 오류: {str(e)}")
-        return "이 슬라이드에서는 핵심 내용을 설명해 주세요."
-def generate_closing_notes(topic: str, conclusion_phrase: str, audience_type: str) -> str:
-    """마지막 슬라이드의 발표자 노트 생성"""
-    print(f"[마무리 노트] 생성 중...")
-    # 오디언스 정보 가져오기
-    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    system_prompt = f"""You are a professional presentation coach creating closing speaker notes.
-The audience for this presentation is: {audience_type} - {audience_info['description']}
-Tone: {audience_info['tone']}
-Create natural closing remarks that:
-1. Thank the {audience_type} audience warmly and appropriately
-2. Briefly summarize the key message relevant to {audience_type}
-3. Reference the conclusion phrase naturally
-4. End with an invitation for questions or next steps appropriate for {audience_type}
-5. Be 80-100 words long
-6. Sound conversational and warm
-7. NO stage directions or parentheses - only spoken words
-Write only what the speaker would say out loud."""
-    user_message = f"""Presentation topic: {topic}
-Audience: {audience_type}
-Conclusion phrase on screen: {conclusion_phrase}
-Create natural closing speaker notes that wrap up the presentation effectively for {audience_type}."""
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": system_prompt
-            },
-            {
-                "role": "user",
-                "content": user_message
-            }
-        ],
-        "max_tokens": 200,
-        "temperature": 0.8,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            notes = result['choices'][0]['message']['content'].strip()
-            # 한글 주제인 경우 번역
-            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
-                notes = translate_content_to_korean_natural(notes)
-            return notes
-        else:
-            return "오늘 발표를 마무리하며 감사의 말씀을 드립니다. 질문이 있으시면 편하게 말씀해 주세요."
-    except Exception as e:
-        print(f"[마무리 노트] 오류: {str(e)}")
-        return "오늘 발표를 마무리하며 감사의 말씀을 드립니다. 질문이 있으시면 편하게 말씀해 주세요."
-def generate_conclusion_phrase(topic: str, audience_type: str) -> str:
-    """프레젠테이션의 핵심을 담은 결론 문구 생성"""
-    print(f"[결론 문구] 생성 중...")
-    # 오디언스 정보 가져오기
-    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    system_prompt = f"""You are a professional copywriter creating powerful closing statements for presentations.
-The audience is: {audience_type} - {audience_info['description']}
-Focus on: {audience_info['focus']}
-Create a concise, impactful closing phrase that:
-1. Captures the essence of the presentation topic
-2. Resonates with {audience_type}
-3. Is memorable and inspirational
-4. Maximum 5-7 words
-5. Uses powerful, action-oriented language appropriate for {audience_type}
-6. Leaves a lasting impression
-Examples for different audiences:
-- For executives: "Excellence Through Strategic Innovation"
-- For investors: "Maximum Returns, Minimal Risk"
-- For technical teams: "Code Today, Transform Tomorrow"
-- For customers: "Your Success, Our Mission"
-Output only the phrase, no explanation."""
-    user_message = f"""Presentation topic: {topic}
-Target audience: {audience_type}
-Create a powerful closing phrase that encapsulates the main message for {audience_type}."""
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": system_prompt
-            },
-            {
-                "role": "user",
-                "content": user_message
-            }
-        ],
-        "max_tokens": 50,
-        "temperature": 0.9,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            phrase = result['choices'][0]['message']['content'].strip()
-            # 한글 주제인 경우 번역
-            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
-                phrase = translate_content_to_korean_concise(phrase)
-            return phrase
-        else:
-            return "함께 만드는 미래"
-    except Exception as e:
-        print(f"[결론 문구] 오류: {str(e)}")
-        return "함께 만드는 미래"
-def generate_slide_content(topic: str, slide_title: str, slide_context: str, audience_type: str,
-                          uploaded_content: str = None, web_search_results: List[Dict] = None) -> Dict[str, str]:
-    """각 슬라이드의 텍스트 내용 생성"""
-    print(f"[슬라이드 내용] {slide_title} 텍스트 생성 중... (대상: {audience_type})")
-    # 오디언스 정보 가져오기
-    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    system_prompt = f"""You are a professional presentation content writer specializing in creating concise, impactful slide content.
-Target Audience: {audience_type} - {audience_info['description']}
-Tone: {audience_info['tone']}
-Focus: {audience_info['focus']}
-Your task is to create content specifically tailored for {audience_type}:
-1. A compelling subtitle (max 10 words) that resonates with {audience_type}
-2. Exactly 5 bullet points with emojis relevant to {audience_type}'s interests
-3. Each bullet point should be 8-12 words
-4. Use noun-ending style (명사형 종결) for Korean or concise fragments for English
-5. Content should address {audience_type}'s specific concerns and interests
-IMPORTANT Style Guidelines:
-- End sentences with nouns or concise phrases
-- Avoid long verb endings like "입니다", "습니다"
-- Use short endings like "임", "함" or noun forms
-- Start each bullet with a relevant emoji that {audience_type} would appreciate
-- Be extremely concise and impactful
-Audience-specific emoji guidelines:
-- For executives: 📊 🎯 💰 🏆 🚀 📈 🔝 💡
-- For investors: 💰 📈 💎 🏦 💸 📊 🚀 🔒
-- For technical teams: 🔧 💻 🛠️ ⚙️ 🔐 🌐 📱 🤖
-- For general staff: 🤝 💡 📋 ✅ 🎯 🌟 📅 💪
-- For customers: ⭐ 🎁 💝 🛡️ 🌟 ✨ 🏅 👍
-- For general public: 😊 🏠 🌍 ❤️ 🎉 🌈 ✨ 🎯
-Output format (EXACTLY FOLLOW THIS FORMAT):
-Subtitle: [subtitle here]
-- 🎯 [Point 1 - tailored for {audience_type}]
-- 📊 [Point 2 - tailored for {audience_type}]
-- 💡 [Point 3 - tailored for {audience_type}]
-- 🚀 [Point 4 - tailored for {audience_type}]
-- ⚡ [Point 5 - tailored for {audience_type}]"""
-    user_message = f"""Topic: {topic}
-Slide Title: {slide_title}
-Context: {slide_context}
-Target Audience: {audience_type}"""
-    # 업로드된 콘텐츠가 있으면 추가
-    if uploaded_content:
-        user_message += f"\n\nReference Material:\n{uploaded_content[:1000]}"
-    # 웹 검색 결과가 있으면 추가
-    if web_search_results:
-        search_context = "\n\nWeb Search Results:\n"
-        for result in web_search_results[:3]:
-            search_context += f"- {result['title']}: {result['description']}\n"
-        user_message += search_context
-    user_message += f"\n\nCreate compelling content for this presentation slide specifically tailored for {audience_type}. Remember to use emojis and concise noun-ending style."
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": system_prompt
-            },
-            {
-                "role": "user",
-                "content": user_message
-            }
-        ],
-        "max_tokens": 300,
-        "top_p": 0.8,
-        "temperature": 0.7,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            content = result['choices'][0]['message']['content'].strip()
-            print(f"[슬라이드 내용] LLM 응답:\n{content}")
-            # Parse content - 더 강건한 파싱
-            lines = content.split('\n')
-            subtitle = ""
-            bullet_points = []
-            for line in lines:
-                line = line.strip()
-                if not line:
-                    continue
-                # Subtitle 파싱
-                if line.lower().startswith("subtitle:") or line.startswith("Subtitle:"):
-                    subtitle = line.split(':', 1)[1].strip()
-                # Bullet point 파싱 - • 또는 - 로 시작하는 경우 모두 처리
-                elif line.startswith("•") or line.startswith("-") or (len(line) > 2 and line[1] == ' ' and ord(line[0]) >= 128):
-                    # 이미 • 가 있으면 그대로, 없으면 추가
-                    if not line.startswith("•"):
-                        line = "• " + line.lstrip("- ")
-                    bullet_points.append(line)
-            # 만약 subtitle이 없으면 기본값 사용
-            if not subtitle:
-                subtitle = f"{slide_title} 개요"
-            # 만약 bullet_points가 5개 미만이면 기본값 추가
-            while len(bullet_points) < 5:
-                bullet_points.append(f"• 📌 포인트 {len(bullet_points) + 1}")
-            # 5개만 선택
-            bullet_points = bullet_points[:5]
-            print(f"[슬라이드 내용] 파싱된 subtitle: {subtitle}")
-            print(f"[슬라이드 내용] 파싱된 bullets: {bullet_points}")
-            # 한글로 번역이 필요한 경우
-            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
-                subtitle = translate_content_to_korean(subtitle)
-                # 불릿 포인트는 이모지를 유지하면서 번역
-                translated_bullets = []
-                for point in bullet_points:
-                    # • 제거하고 내용만 추출
-                    clean_point = point.replace('•', '').strip()
-                    # 이모지와 텍스트 분리 (첫 번째 공백을 기준으로)
-                    if len(clean_point) > 0 and clean_point[0] in '🎯📊💡🚀⚡🔍📈💰🏆🔧🌐🔐⭐🎨📱🤝📍🎖️🏗️🌱💻🛠️⚙️🤖📋✅🌟📅💪🎁💝🛡️✨🏅👍😊🏠🌍❤️🎉🌈':
-                        # 이모지가 있는 경우
-                        emoji = clean_point[0]
-                        text = clean_point[1:].strip()
-                        translated_text = translate_content_to_korean_concise(text)
-                        translated_bullets.append(f"• {emoji} {translated_text}")
-                    else:
-                        # 이모지가 없는 경우
-                        translated_bullets.append(f"• {translate_content_to_korean_concise(clean_point)}")
-                bullet_points = translated_bullets
-            return {
-                "subtitle": subtitle,
-                "bullet_points": bullet_points
-            }
-        else:
-            print(f"[슬라이드 내용] API 오류: {response.status_code}")
-            return {
-                "subtitle": slide_title,
-                "bullet_points": ["• 📌 내용 생성 불가"] * 5
-            }
-    except Exception as e:
-        print(f"[슬라이드 내용] 오류: {str(e)}")
-        return {
-            "subtitle": slide_title,
-            "bullet_points": ["• ❌ 내용 생성 오류"] * 5
-        }
-def translate_content_to_korean(text: str) -> str:
-    """영어 텍스트를 한글로 번역 (일반용)"""
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": "You are a translator. Translate the given English text to Korean. Maintain professional business tone. Only return the translation without any explanation."
-            },
-            {
-                "role": "user",
-                "content": text
-            }
-        ],
-        "max_tokens": 200,
-        "top_p": 0.8,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            return result['choices'][0]['message']['content'].strip()
-        else:
-            return text
-    except Exception as e:
-        return text
-def translate_content_to_korean_concise(text: str) -> str:
-    """영어 텍스트를 간결한 한글로 번역 (명사형 종결)"""
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": """You are a translator specializing in concise Korean business presentations.
-Translate to Korean using noun-ending style (명사형 종결어미).
-End with "임", "함", or noun forms instead of "입니다", "습니다".
-Keep it extremely concise and professional.
-Examples: "전략적 확대", "핵심 과제 도출", "시장 선도 전략 수립"
-Only return the translation without any explanation."""
-            },
-            {
-                "role": "user",
-                "content": text
-            }
-        ],
-        "max_tokens": 200,
-        "top_p": 0.8,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            return result['choices'][0]['message']['content'].strip()
-        else:
-            return text
-    except Exception as e:
-        return text
-def translate_content_to_korean_natural(text: str) -> str:
-    """영어 텍스트를 자연스러운 한글로 번역 (발표 노트용)"""
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": """You are a translator. Translate the given English text to natural, conversational Korean.
-Use polite spoken language suitable for presentations.
-Only return the translation without any explanation."""
-            },
-            {
-                "role": "user",
-                "content": text
-            }
-        ],
-        "max_tokens": 300,
-        "top_p": 0.8,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            return result['choices'][0]['message']['content'].strip()
-        else:
-            return text
-    except Exception as e:
-        return text
-def generate_prompt_with_llm(topic: str, style_example: str = None, slide_context: str = None, uploaded_content: str = None) -> str:
-    """주제와 스타일 예제를 받아서 LLM을 사용해 이미지 프롬프트를 생성"""
-    print(f"[LLM] 프롬프트 생성 시작: {slide_context}")
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    system_prompt = """You are an expert image prompt engineer specializing in creating prompts for professional presentation slides.
-Your task is to create prompts that:
-1. Are highly specific and visual, perfect for PPT backgrounds or main visuals
-2. Consider the slide's purpose and maintain consistency across a presentation
-3. Include style references matching the given example
-4. Focus on clean, professional visuals that won't distract from text overlays
-5. Ensure high contrast areas for text readability when needed
-6. Maintain brand consistency and professional aesthetics
-Important guidelines:
-- If given a style example, adapt the topic to match that specific visual style
-- Consider the slide context (e.g., "표지", "현황 분석") to create appropriate visuals
-- Always output ONLY the prompt without any explanation
-- Keep prompts between 50-150 words for optimal results
-- Ensure the visual supports rather than overwhelms the slide content"""
-    user_message = f"Topic: {topic}"
-    if style_example:
-        user_message += f"\n\nStyle reference to follow:\n{style_example}"
-    if slide_context:
-        user_message += f"\n\nSlide context: {slide_context}"
-    if uploaded_content:
-        user_message += f"\n\nAdditional context from document:\n{uploaded_content[:500]}"
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": system_prompt
-            },
-            {
-                "role": "user",
-                "content": user_message
-            }
-        ],
-        "max_tokens": 300,
-        "top_p": 0.8,
-        "temperature": 0.7,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            prompt = result['choices'][0]['message']['content'].strip()
-            print(f"[LLM] 프롬프트 생성 완료: {prompt[:50]}...")
-            return prompt
-        else:
-            error_msg = f"프롬프트 생성 실패: {response.status_code}"
-            print(f"[LLM] {error_msg}")
-            return error_msg
-    except Exception as e:
-        error_msg = f"프롬프트 생성 중 오류 발생: {str(e)}"
-        print(f"[LLM] {error_msg}")
-        return error_msg
-def translate_to_english(text: str) -> str:
-    """한글 텍스트를 영어로 번역 (LLM 사용)"""
-    if not any(ord('가') <= ord(char) <= ord('힣') for char in text):
-        return text
-    print(f"[번역] 한글 감지, 영어로 번역 시작")
-    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "model": "dep89a2fld32mcm",
-        "messages": [
-            {
-                "role": "system",
-                "content": "You are a translator. Translate the given Korean text to English. Only return the translation without any explanation."
-            },
-            {
-                "role": "user",
-                "content": text
-            }
-        ],
-        "max_tokens": 500,
-        "top_p": 0.8,
-        "stream": False
-    }
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        if response.status_code == 200:
-            result = response.json()
-            translated = result['choices'][0]['message']['content'].strip()
-            print(f"[번역] 완료")
-            return translated
-        else:
-            print(f"[번역] 실패, 원본 사용")
-            return text
-    except Exception as e:
-        print(f"[번역] 오류: {str(e)}, 원본 사용")
-        return text
-def generate_image(prompt: str, seed: int = 10, slide_info: str = "") -> Tuple[Image.Image, str]:
-    """Replicate API를 사용해 이미지 생성 또는 프로세스 플로우 다이어그램 생성"""
-    print(f"\n[이미지 생성] {slide_info}")
-    print(f"[이미지 생성] 프롬프트: {prompt[:50]}...")
-    global current_topic, uploaded_content
-    # 프로세스 플로우 다이어그램 생성 조건 확인
-    should_generate_process_flow = False
-    # 슬라이드 정보에서 제목 추출
-    slide_title = ""
-    if ":" in slide_info:
-        # "슬라이드 5: 프로세스" 형태에서 "프로세스" 추출
-        parts = slide_info.split(":")
-        if len(parts) >= 2:
-            slide_title = parts[1].strip()
-    print(f"[이미지 생성] 추출된 슬라이드 제목: '{slide_title}'")
-    # 1. 프로세스 관련 키워드가 슬라이드 제목에 포함되어 있는지 확인
-    process_keywords = [
-        "프로세스", "작동", "플로우", "흐름", "워크플로우",
-        "절차", "단계", "처리", "진행", "개요"
-    ]
-    # 2. 스타일 확인
-    is_workflow_style = False
-    if any(style in prompt for style in ["Business Workflow", "Flowchart", "Business Process"]):
-        is_workflow_style = True
-        print(f"[이미지 생성] Business Workflow 또는 Flowchart 스타일 감지")
-    # 3. 슬라이드 제목에 프로세스 키워드가 있거나, 스타일이 워크플로우인 경우
-    title_has_process = any(keyword in slide_title for keyword in process_keywords)
-    prompt_has_process = any(keyword in prompt.lower() for keyword in ["process", "flow", "workflow"])
-    print(f"[이미지 생성] 제목에 프로세스 키워드: {title_has_process}")
-    print(f"[이미지 생성] 워크플로우 스타일: {is_workflow_style}")
-    print(f"[이미지 생성] 프롬프트에 프로세스 키워드: {prompt_has_process}")
-    # 조건 완화: 제목에 프로세스 키워드가 있고, 스타일이 맞거나 프롬프트에 관련 키워드가 있으면 생성
-    if title_has_process and (is_workflow_style or prompt_has_process):
-        should_generate_process_flow = True
-        print(f"[이미지 생성] ✅ 프로세스 플로우 다이어그램 생성 조건 충족!")
-    # 특별 케이스: "목차"는 프로세스 플로우가 아닌 일반 이미지로
-    if "목차" in slide_title:
-        should_generate_process_flow = False
-        print(f"[이미지 생성] 목차는 프로세스 플로우 제외")
-    # 프로세스 플로우 다이어그램 생성
-    if PROCESS_FLOW_AVAILABLE and should_generate_process_flow:
-        try:
-            print("[이미지 생성] 🔧 프로세스 플로우 다이어그램 생성 시작...")
-            # 슬라이드 컨텍스트를 기반으로 적절한 프로세스 플로우 생성
-            img = generate_process_flow_for_ppt(
-                topic=current_topic,
-                context=slide_info,
-                style="Business Workflow"
-            )
-            if isinstance(img, Image.Image):
-                print("[이미지 생성] ✅ 프로세스 플로우 다이어그램 생성 성공!")
-                return img, "Process flow diagram generated with Korean support"
-            else:
-                print("[이미지 생성] ❌ 프로세스 플로우 생성 실패, 일반 이미지로 대체")
-        except Exception as e:
-            print(f"[이미지 생성] ❌ 프로세스 플로우 생성 오류: {str(e)}")
-            import traceback
-            traceback.print_exc()
-            # 실패시 일반 이미지 생성으로 폴백
-    else:
-        if not PROCESS_FLOW_AVAILABLE:
-            print("[이미지 생성] ⚠️ 프로세스 플로우 생성기를 사용할 수 없음")
-        else:
-            print("[이미지 생성] ℹ️ 프로세스 플로우 생성 조건 미충족, 일반 이미지 생성")
-    # 기존 이미지 생성 로직
     try:
-        english_prompt = translate_to_english(prompt)
-        if not REPLICATE_API_TOKEN:
-            error_msg = "RAPI_TOKEN 환경변수가 설정되지 않았습니다."
-            print(f"[이미지 생성] 오류: {error_msg}")
-            return None, error_msg
-        print(f"[이미지 생성] Replicate API 호출 중...")
-        client = replicate.Client(api_token=REPLICATE_API_TOKEN)
-        input_params = {
-            "seed": seed,
-            "prompt": english_prompt,
-            "speed_mode": "Extra Juiced 🚀 (even more speed)",
-            "output_quality": 100
-        }
-        start_time = time.time()
-        output = client.run(
-            "prunaai/hidream-l1-fast:17c237d753218fed0ed477cb553902b6b75735f48c128537ab829096ef3d3645",
-            input=input_params
-        )
-        elapsed = time.time() - start_time
-        print(f"[이미지 생성] API 응답 받음 ({elapsed:.1f}초)")
-        if output:
-            if isinstance(output, str) and output.startswith('http'):
-                print(f"[이미지 생성] URL에서 이미지 다운로드 중...")
-                response = requests.get(output, timeout=30)
-                img = Image.open(BytesIO(response.content))
-                print(f"[이미지 생성] 완료!")
-                return img, english_prompt
-            else:
-                print(f"[이미지 생성] 바이너리 데이터 처리 중...")
-                img = Image.open(BytesIO(output.read()))
-                print(f"[이미지 생성] 완료!")
-                return img, english_prompt
-        else:
-            error_msg = "이미지 생성 실패 - 빈 응답"
-            print(f"[이미지 생성] {error_msg}")
-            return None, error_msg
-    except Exception as e:
-        error_msg = f"오류: {str(e)}"
-        print(f"[이미지 생성] {error_msg}")
-        print(f"[이미지 생성] 상세 오류:\n{traceback.format_exc()}")
-        return None, error_msg
-def create_slide_preview_html(slide_data: Dict) -> str:
-    """16:9 비율의 슬라이드 프리뷰 HTML 생성 (편집 기능 제거)"""
-    # 이미지를 base64로 인코딩
-    img_base64 = ""
-    if slide_data.get("image"):
-        buffered = BytesIO()
-        slide_data["image"].save(buffered, format="PNG")
-        img_base64 = base64.b64encode(buffered.getvalue()).decode()
-    # 텍스트 내용 가져오기
-    subtitle = slide_data.get("subtitle", "")
-    bullet_points = slide_data.get("bullet_points", [])
-    # HTML 생성
-    html = f"""
-    <div class="slide-container" style="
-        width: 100%;
-        max-width: 1200px;
-        margin: 20px auto;
-        background: white;
-        border-radius: 12px;
-        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
-        overflow: hidden;
-    ">
-        <div class="slide-header" style="
-            background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
-            color: white;
-            padding: 15px 30px;
-            font-size: 18px;
-            font-weight: bold;
-        ">
-            슬라이드 {slide_data.get('slide_number', '')}: {slide_data.get('title', '')}
-        </div>
-        <div class="slide-content" style="
-            display: flex;
-            height: 0;
-            padding-bottom: 56.25%; /* 16:9 비율 */
-            position: relative;
-            background: #fafbfc;
-        ">
-            <div class="slide-inner" style="
-                position: absolute;
-                top: 0;
-                left: 0;
-                width: 100%;
-                height: 100%;
-                display: flex;
-                padding: 20px;
-                gap: 20px;
-            ">
-    """
-    # 표지와 마지막 슬라이드는 전체 화면 이미지
-    if slide_data.get('title') in ['표지', 'Thank You']:
-        html += f"""
-                <!-- 전체 화면 이미지 -->
-                <div style="
-                    width: 100%;
-                    height: 100%;
-                    position: relative;
-                    background: #e9ecef;
-                    border-radius: 12px;
-                    overflow: hidden;
-                ">
-        """
-        if img_base64:
-            html += f"""
-                    <img src="data:image/png;base64,{img_base64}" style="
-                        width: 100%;
-                        height: 100%;
-                        object-fit: cover;
-                    " alt="Slide Image">
-                    <div style="
-                        position: absolute;
-                        top: 50%;
-                        left: 50%;
-                        transform: translate(-50%, -50%);
-                        text-align: center;
-                        background: rgba(255, 255, 255, 0.9);
-                        padding: 30px 60px;
-                        border-radius: 20px;
-                        box-shadow: 0 10px 40px rgba(0,0,0,0.3);
-                        backdrop-filter: blur(10px);
-                    ">
-            """
-            if slide_data.get('title') == '표지':
-                html += f"""
-                        <h1 style="font-size: 48px; margin-bottom: 10px; color: #000000; font-weight: 700;">{slide_data.get('topic', '')}</h1>
-                        <h2 style="font-size: 24px; margin-top: 0; color: #212529; font-weight: 400;">{subtitle}</h2>
-                """
-            else:  # Thank You
-                html += f"""
-                        <h1 style="font-size: 42px; color: #000000; font-weight: 700; line-height: 1.2;">{subtitle}</h1>
-                """
-            html += """
-                    </div>
-            """
-        html += """
-                </div>
-        """
-    else:
-        # 일반 슬라이드 레이아웃
-        html += f"""
-                <!-- 텍스트 영역 (좌측) -->
-                <div class="text-area" style="
-                    flex: 1;
-                    padding: 30px;
-                    display: flex;
-                    flex-direction: column;
-                    justify-content: center;
-                    background: rgba(255, 255, 255, 0.95);
-                    border-radius: 12px;
-                    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.08);
-                ">
-                    <h2 style="
-                        color: #212529;
-                        font-size: 28px;
-                        margin-bottom: 30px;
-                        font-weight: 600;
-                    ">{subtitle}</h2>
-                    <ul style="
-                        list-style: none;
-                        padding: 0;
-                        margin: 0;
-                    ">
-        """
-        for point in bullet_points:
-            clean_point = point.replace('•', '').strip()
-            html += f"""
-                        <li style="
-                            margin-bottom: 16px;
-                            padding-left: 28px;
-                            position: relative;
-                            color: #495057;
-                            font-size: 16px;
-                            line-height: 1.6;
-                        ">
-                            <span style="
-                                position: absolute;
-                                left: 0;
-                                color: #007bff;
-                                font-size: 18px;
-                            ">•</span>
-                            {clean_point}
-                        </li>
-            """
-        html += f"""
-                    </ul>
-                </div>
-                <!-- 이미지 영역 (우측) -->
-                <div class="image-area" style="
-                    flex: 1;
-                    display: flex;
-                    align-items: center;
-                    justify-content: center;
-                    padding: 20px;
-                ">
-        """
-        if img_base64:
-            html += f"""
-                    <img src="data:image/png;base64,{img_base64}" style="
-                        max-width: 100%;
-                        max-height: 100%;
-                        object-fit: contain;
-                        border-radius: 8px;
-                        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
-                    " alt="Slide Image">
-            """
-        else:
-            html += """
-                    <div style="
-                        color: #6c757d;
-                        text-align: center;
-                    ">
-                        <div style="font-size: 48px;">🖼️</div>
-                        <p>이미지 생성 중...</p>
-                    </div>
-            """
-        html += """
-                </div>
-        """
-    html += """
-            </div>
-        </div>
-    </div>
-    """
-    return html
-def create_pptx_file(results: List[Dict], topic: str, template_name: str, theme_name: str = "미니멀 라이트") -> str:
-    """생성된 결과를 PPTX 파일로 변환 (발표자 노트 포함)"""
-    print(f"[PPTX] 파일 생성 시작... 테마: {theme_name}")
-    # 프레젠테이션 생성 (16:9 비율)
-    prs = Presentation()
-    prs.slide_width = Inches(16)
-    prs.slide_height = Inches(9)
-    # 선택된 테마 가져오기
-    theme = DESIGN_THEMES.get(theme_name, DESIGN_THEMES["미니멀 라이트"])
-    # 각 결과 슬라이드 추가
-    for i, result in enumerate(results):
-        if not result.get("success", False):
-            continue
-        slide_data = result.get("slide_data", {})
-        # 빈 레이아웃 사용 (제목 플레이스홀더 없는 완전한 빈 슬라이드)
-        blank_layout = prs.slide_layouts[6]  # 완전히 빈 레이아웃
-        slide = prs.slides.add_slide(blank_layout)
-        # 표지 슬라이드
-        if slide_data.get('title') == '표지':
-            # 배경 이미지 추가
-            if slide_data.get('image'):
-                try:
-                    img_buffer = BytesIO()
-                    slide_data['image'].save(img_buffer, format='PNG')
-                    img_buffer.seek(0)
-                    # 전체 화면 배경 이미지
-                    pic = slide.shapes.add_picture(
-                        img_buffer,
-                        0, 0,
-                        width=prs.slide_width,
-                        height=prs.slide_height
-                    )
-                    # 맨 뒤로 보내기
-                    slide.shapes._spTree.remove(pic._element)
-                    slide.shapes._spTree.insert(2, pic._element)
-                except Exception as e:
-                    print(f"[PPTX] 표지 이미지 추가 실패: {str(e)}")
-            # 제목 배경 박스 (반투명 - 더 투명하게)
-            title_bg = slide.shapes.add_shape(
-                MSO_SHAPE.ROUNDED_RECTANGLE,
-                Inches(2), Inches(2.8),
-                Inches(12), Inches(3.2)
-            )
-            title_bg.fill.solid()
-            title_bg.fill.fore_color.rgb = RGBColor(255, 255, 255)  # 흰색 배경
-            title_bg.fill.transparency = 0.8  # 50% 투명도 (더 투명하게)
-            title_bg.line.fill.background()
-            # 그림자 효과 추가 (더 약하게)
-            shadow = title_bg.shadow
-            shadow.visible = True
-            shadow.distance = Pt(6)
-            shadow.size = 100
-            shadow.blur_radius = Pt(12)
-            shadow.transparency = 0.8
-            shadow.angle = 45
-            # 제목 텍스트 추가
-            title_box = slide.shapes.add_textbox(
-                Inches(2), Inches(3.2),
-                Inches(12), Inches(1.5)
-            )
-            title_frame = title_box.text_frame
-            title_frame.text = topic
-            title_para = title_frame.paragraphs[0]
-            title_para.font.size = Pt(48)
-            title_para.font.bold = True
-            title_para.font.color.rgb = RGBColor(0, 0, 0)  # 완전한 검정색
-            title_para.alignment = PP_ALIGN.CENTER
-            # 부제목 추가 (제목과 가까이)
-            subtitle_box = slide.shapes.add_textbox(
-                Inches(2), Inches(4.3),
-                Inches(12), Inches(1.0)
-            )
-            subtitle_frame = subtitle_box.text_frame
-            subtitle_frame.text = slide_data.get('subtitle', f'{template_name} - AI 프레젠테이션')
-            subtitle_para = subtitle_frame.paragraphs[0]
-            subtitle_para.font.size = Pt(28)  # 24에서 28로 증가
-            subtitle_para.font.color.rgb = RGBColor(33, 37, 41)  # 진한 회색
-            subtitle_para.alignment = PP_ALIGN.CENTER
-        # Thank You 슬라이드
-        elif slide_data.get('title') == 'Thank You':
-            # 배경 이미지 추가
-            if slide_data.get('image'):
-                try:
-                    img_buffer = BytesIO()
-                    slide_data['image'].save(img_buffer, format='PNG')
-                    img_buffer.seek(0)
-                    # 전체 화면 배경 이미지
-                    pic = slide.shapes.add_picture(
-                        img_buffer,
-                        0, 0,
-                        width=prs.slide_width,
-                        height=prs.slide_height
-                    )
-                    # 맨 뒤로 보내기
-                    slide.shapes._spTree.remove(pic._element)
-                    slide.shapes._spTree.insert(2, pic._element)
-                except Exception as e:
-                    print(f"[PPTX] Thank You 이미지 추가 실패: {str(e)}")
-            # Thank You 배경 박스 (반투명 - 더 투명하게)
-            thanks_bg = slide.shapes.add_shape(
-                MSO_SHAPE.ROUNDED_RECTANGLE,
-                Inches(2), Inches(3.5),
-                Inches(12), Inches(2.5)
-            )
-            thanks_bg.fill.solid()
-            thanks_bg.fill.fore_color.rgb = RGBColor(255, 255, 255)  # 흰색 배경
-            thanks_bg.fill.transparency = 0.8  # 50% 투명도 (더 투명하게)
-            thanks_bg.line.fill.background()
-            # 그림자 효과 추가 (더 약하게)
-            shadow = thanks_bg.shadow
-            shadow.visible = True
-            shadow.distance = Pt(6)
-            shadow.size = 100
-            shadow.blur_radius = Pt(12)
-            shadow.transparency = 0.8
-            shadow.angle = 45
-            # Thank You 텍스트 (결론 문구)
-            thanks_box = slide.shapes.add_textbox(
-                Inches(2), Inches(4),
-                Inches(12), Inches(1.5)
-            )
-            thanks_frame = thanks_box.text_frame
-            thanks_frame.text = slide_data.get('subtitle', 'Thank You')  # 결론 문구 사용
-            thanks_para = thanks_frame.paragraphs[0]
-            thanks_para.font.size = Pt(42)  # 크기를 조금 줄임
-            thanks_para.font.bold = True
-            thanks_para.font.color.rgb = RGBColor(0, 0, 0)  # 완전한 검정색
-            thanks_para.alignment = PP_ALIGN.CENTER
-        # 일반 슬라이드
-        else:
-            # 배경색 설정
-            background = slide.background
-            fill = background.fill
-            fill.solid()
-            fill.fore_color.rgb = theme["background"]
-            # 슬라이드 제목 배경 박스 (둥근 모서리 효과)
-            title_box_bg = slide.shapes.add_shape(
-                MSO_SHAPE.ROUNDED_RECTANGLE,
-                Inches(0.3), Inches(0.2),
-                Inches(15.4), Inches(1.0)
-            )
-            title_box_bg.fill.solid()
-            title_box_bg.fill.fore_color.rgb = theme["box_fill"]
-            title_box_bg.fill.transparency = 1 - theme["box_opacity"]
-            # 그림자 효과
-            if theme["shadow"]:
-                shadow = title_box_bg.shadow
-                shadow.visible = True
-                shadow.distance = Pt(4)
-                shadow.size = 100
-                shadow.blur_radius = Pt(8)
-                shadow.transparency = 0.75
-                shadow.angle = 45
-            title_box_bg.line.fill.background()  # 테두리 없음
-            # 슬라이드 제목 추가
-            title_box = slide.shapes.add_textbox(
-                Inches(0.5), Inches(0.3),
-                Inches(15), Inches(0.8)
-            )
-            title_frame = title_box.text_frame
-            title_frame.text = f"{slide_data.get('title', '')}"
-            title_para = title_frame.paragraphs[0]
-            title_para.font.size = Pt(28)
-            title_para.font.bold = True
-            title_para.font.color.rgb = theme["title_color"]
-            # 좌측 텍스트 영역 배경 박스
-            text_box_bg = slide.shapes.add_shape(
-                MSO_SHAPE.ROUNDED_RECTANGLE,
-                Inches(0.3), Inches(1.4),
-                Inches(7.8), Inches(6.8)
-            )
-            text_box_bg.fill.solid()
-            text_box_bg.fill.fore_color.rgb = theme["box_fill"]
-            text_box_bg.fill.transparency = 1 - theme["box_opacity"]
-            if theme["shadow"]:
-                shadow = text_box_bg.shadow
-                shadow.visible = True
-                shadow.distance = Pt(5)
-                shadow.size = 100
-                shadow.blur_radius = Pt(10)
-                shadow.transparency = 0.7
-                shadow.angle = 45
-            text_box_bg.line.fill.background()
-            # 좌측 텍스트 영역
-            text_box = slide.shapes.add_textbox(
-                Inches(0.8), Inches(1.8),
-                Inches(7.0), Inches(6.0)
-            )
-            text_frame = text_box.text_frame
-            text_frame.word_wrap = True
-            # 소제목 추가
-            subtitle_para = text_frame.paragraphs[0]
-            subtitle_para.text = slide_data.get('subtitle', '')
-            subtitle_para.font.size = Pt(20)
-            subtitle_para.font.bold = True
-            subtitle_para.font.color.rgb = theme["subtitle_color"]
-            subtitle_para.space_after = Pt(20)
-            # 불릿 포인트 추가
-            bullet_points = slide_data.get('bullet_points', [])
-            for point in bullet_points:
-                p = text_frame.add_paragraph()
-                # • 제거하고 텍스트만 추가 (이모지는 유지)
-                clean_text = point.replace('•', '').strip()
-                p.text = clean_text
-                p.font.size = Pt(16)
-                p.font.color.rgb = theme["text_color"]
-                # 불릿 없이 들여쓰기만
-                p.level = 0
-                p.space_after = Pt(12)
-                p.line_spacing = 1.5
-                # 왼쪽 여백 설정
-                p.left_indent = Pt(0)
-                # 불릿 색상
-                p.font.color.rgb = theme["text_color"]
-            # 우측 ��미지 추가 (배경 박스 제거)
-            if slide_data.get('image'):
-                try:
-                    img_buffer = BytesIO()
-                    slide_data['image'].save(img_buffer, format='PNG')
-                    img_buffer.seek(0)
-                    pic = slide.shapes.add_picture(
-                        img_buffer,
-                        Inches(8.5), Inches(1.6),
-                        width=Inches(6.8), height=Inches(6.4)
-                    )
-                    # 이미지 테두리 제거
-                    pic.line.fill.background()
-                except Exception as e:
-                    print(f"[PPTX] 이미지 추가 실패: {str(e)}")
-            # 페이지 번호 추가
-            page_num = slide.shapes.add_textbox(
-                Inches(15), Inches(8.5),
-                Inches(1), Inches(0.5)
-            )
-            page_frame = page_num.text_frame
-            page_frame.text = str(i + 1)
-            page_para = page_frame.paragraphs[0]
-            page_para.font.size = Pt(12)
-            page_para.font.color.rgb = theme["text_color"]
-            page_para.alignment = PP_ALIGN.RIGHT
-        # 발표자 노트 추가
-        notes_slide = slide.notes_slide
-        notes_slide.notes_text_frame.text = slide_data.get('speaker_notes', '')
-    # 파일 저장
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"presentation_{timestamp}.pptx"
-    filepath = os.path.join("/tmp", filename)
-    prs.save(filepath)
-    print(f"[PPTX] 파일 생성 완료: {filename}")
-    return filepath
-def generate_dynamic_slides(topic: str, template: Dict, slide_count: int) -> List[Dict]:
-    """선택된 슬라이드 수에 따라 동적으로 슬라이드 구성"""
-    core_slides = template.get("core_slides", [])
-    optional_slides = template.get("optional_slides", [])
-    # 표지와 Thank You를 제외한 본문 슬라이드 수
-    content_slide_count = slide_count
-    # 코어 슬라이드가 요청된 수보다 많으면 조정
-    if len(core_slides) > content_slide_count:
-        selected_slides = core_slides[:content_slide_count]
-    else:
-        # 코어 슬라이드 + 옵셔널 슬라이드에서 선택
-        selected_slides = core_slides.copy()
-        remaining = content_slide_count - len(core_slides)
-        if remaining > 0 and optional_slides:
-            # 옵셔널 슬라이드에서 추가 선택
-            additional = optional_slides[:remaining]
-            selected_slides.extend(additional)
-    # 표지 추가 (맨 앞)
-    slides = [{"title": "표지", "style": "Title Slide (Hero)", "prompt_hint": "프레젠테이션 표지"}]
-    # 본문 슬라이드 추가
-    slides.extend(selected_slides)
-    # Thank You 슬라이드 추가 (맨 뒤)
-    slides.append({"title": "Thank You", "style": "Thank You Slide", "prompt_hint": "프레젠테이션 마무리와 핵심 메시지"})
-    return slides
-def create_custom_slides_ui(initial_count=5):
-    """사용자 정의 슬라이드 구성 UI (3-20장)"""
-    slides = []
-    for i in range(20):  # 최대 20장
-        row = gr.Row(visible=(i < initial_count))  # Row를 변수에 할당
-        with row:
-            with gr.Column(scale=2):
-                title = gr.Textbox(
-                    label=f"슬라이드 {i+1} 제목",
-                    placeholder="예: 현황 분석, 솔루션, 로드맵...",
-                )
-            with gr.Column(scale=3):
-                style = gr.Dropdown(
-                    choices=list(STYLE_TEMPLATES.keys()),
-                    label=f"스타일 선택",
-                    value="Colorful Mind Map"
-                )
-            with gr.Column(scale=3):
-                hint = gr.Textbox(
-                    label=f"프롬프트 힌트",
-                    placeholder="이 슬라이드에서 표현하고 싶은 내용"
-                )
-        slides.append({"title": title, "style": style, "hint": hint, "row": row})
-    return slides
-def generate_ppt_with_content(topic: str, template_name: str, audience_type: str, custom_slides: List[Dict],
-                             slide_count: int, seed: int, uploaded_file,
-                             use_web_search: bool, theme_name: str = "미니멀 라이트",
-                             progress=gr.Progress()):
-    """PPT 이미지와 텍스트 내용을 함께 생성 (발표자 노트 포함)"""
-    results = []
-    preview_html = ""
-    # 전역 변수 업데이트
-    global current_topic, uploaded_content
-    current_topic = topic
-    # 업로드된 파일 내용 읽기
-    uploaded_content = ""
-    if uploaded_file is not None:
         try:
-            uploaded_content = read_uploaded_file(uploaded_file.name)
-            print(f"[파일 업로드] 내용 길이: {len(uploaded_content)}자")
-        except Exception as e:
-            print(f"[파일 업로드] 오류: {str(e)}")
-            uploaded_content = ""
-    # 템플릿 선택 및 슬라이드 구성
-    if template_name == "사용자 정의" and custom_slides:
-        slides = [{"title": "표지", "style": "Title Slide (Hero)", "prompt_hint": "프레젠테이션 표지"}]
-        slides.extend(custom_slides)
-        slides.append({"title": "Thank You", "style": "Thank You Slide", "prompt_hint": "프레젠테이션 마무리와 핵심 메시지"})
-    else:
-        template = PPT_TEMPLATES[template_name]
-        slides = generate_dynamic_slides(topic, template, slide_count)
-    if not slides:
-        yield "", "슬라이드가 정의되지 않았습니다.", None
-        return
-    total_slides = len(slides)
-    print(f"\n[PPT 생성] 시작 - 총 {total_slides}개 슬라이드 (표지 + 본문 {slide_count} + Thank You)")
-    print(f"[PPT 생성] 주제: {topic}")
-    print(f"[PPT 생성] 템플릿: {template_name}")
-    print(f"[PPT 생성] 오디언스: {audience_type}")
-    print(f"[PPT 생성] 디자인 테마: {theme_name}")
-    print(f"[PPT 생성] 웹 검색: {'사용' if use_web_search else '미사용'}")
-    # 웹 검색 실행 (선택된 경우)
-    web_search_results = []
-    if use_web_search and BRAVE_API_TOKEN:
-        progress(0.05, "웹 검색 중...")
-        web_search_results = brave_search(topic)
-    # CSS 스타일 추가
-    preview_html = """
-    <style>
-        .slides-container {
-            width: 100%;
-            max-width: 1400px;
-            margin: 0 auto;
-        }
-    </style>
-    <div class="slides-container">
-    """
-    # 각 슬라이드 순차 처리
-    for i, slide in enumerate(slides):
-        progress((i + 1) / (total_slides + 1), f"슬라이드 {i+1}/{total_slides} 처리 중...")
-        slide_info = f"슬라이드 {i+1}: {slide['title']}"
-        # 텍스트 내용 생성
-        slide_context = f"{slide['title']} - {slide.get('prompt_hint', '')}"
-        # Thank You 슬라이드는 결론 문구 생성
-        if slide['title'] == 'Thank You':
-            conclusion_phrase = generate_conclusion_phrase(topic, audience_type)
-            content = {
-                "subtitle": conclusion_phrase,
-                "bullet_points": []
-            }
-            # Thank You 슬라이드용 특별 노트
-            speaker_notes = generate_closing_notes(topic, conclusion_phrase, audience_type)
-        else:
-            content = generate_slide_content(
-                topic, slide['title'], slide_context, audience_type,
-                uploaded_content, web_search_results
-            )
-            # 일반 슬라이드 발표자 노트
-            speaker_notes = generate_presentation_notes(topic, slide['title'], content, audience_type)
-        # 프롬프트 생성 및 이미지 생성
-        style_key = slide["style"]
-        if style_key in STYLE_TEMPLATES:
-            style_info = STYLE_TEMPLATES[style_key]
-            prompt = generate_prompt_with_llm(
-                topic, style_info["example"],
-                slide_context, uploaded_content
-            )
-            # 이미지 생성 (프로세스 플로우 다이어그램 지원 포함)
-            slide_seed = seed + i
-            img, used_prompt = generate_image(prompt, slide_seed, slide_info)
-            # 슬라이드 데이터 구성
-            slide_data = {
-                "slide_number": i + 1,
-                "title": slide["title"],
-                "subtitle": content["subtitle"],
-                "bullet_points": content["bullet_points"],
-                "image": img,
-                "style": style_info["name"],
-                "speaker_notes": speaker_notes,
-                "topic": topic  # 표지용
-            }
-            # 프리뷰 HTML 생성 (편집 기능 제거)
-            preview_html += create_slide_preview_html(slide_data)
-            # 현재까지의 상태 업데이트
-            yield preview_html + "</div>", f"### 🔄 {slide_info} 생성 중...", None
-            results.append({
-                "slide_data": slide_data,
-                "success": img is not None
-            })
-    # PPTX 파일 생성
-    progress(0.95, "PPTX 파일 생성 중...")
-    pptx_path = None
-    try:
-        pptx_path = create_pptx_file(results, topic, template_name, theme_name)
     except Exception as e:
-        print(f"[PPTX] 파일 생성 오류: {str(e)}")
-    preview_html += "</div>"
-    progress(1.0, "완료!")
-    successful = sum(1 for r in results if r["success"])
-    final_status = f"### 🎉 생성 완료! 총 {total_slides}개 슬라이드 중 {successful}개 성공"
-    # 전역 변수 저장
-    global current_slides_data, current_template, current_theme
-    current_slides_data = results
-    current_template = template_name
-    current_theme = theme_name
-    if pptx_path:
-        final_status += f"\n\n### 📥 PPTX 파일이 준비되었습니다!"
-        final_status += f"\n\n🎤 **{audience_type}를 위한 발표자 노트가 각 슬라이드에 포함되어 있습니다!**"
-        if PROCESS_FLOW_AVAILABLE:
-            final_status += f"\n\n🔧 **프로세스 플로우 다이어그램이 자동으로 생성됩니다 (한글 지원)**"
-    yield preview_html, final_status, pptx_path
-# Gradio 인터페이스 생성
-with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft(), css="""
-    .preview-container { max-width: 1400px; margin: 0 auto; }
-    .slide-container { transition: all 0.3s ease; }
-    .slide-container:hover { transform: translateY(-2px); box-shadow: 0 12px 24px rgba(0, 0, 0, 0.15) !important; }
-    #custom_accordion .form {
-        max-height: 600px;
-        overflow-y: auto;
-        padding-right: 10px;
-    }
-    #custom_accordion .form::-webkit-scrollbar {
-        width: 6px;
-    }
-    #custom_accordion .form::-webkit-scrollbar-track {
-        background: #f1f1f1;
-        border-radius: 3px;
-    }
-    #custom_accordion .form::-webkit-scrollbar-thumb {
-        background: #888;
-        border-radius: 3px;
-    }
-    #custom_accordion .form::-webkit-scrollbar-thumb:hover {
-        background: #555;
-    }
-""") as demo:
-    gr.Markdown("""
-    # 🎯 AI 기반 PPT 통합 생성기 (간결한 스타일 버전)
-    ### 텍스트와 이미지가 완벽하게 조화된 프레젠테이션을 자동으로 생성하세요!
-    #### 🆕 새로운 기능:
-    - 🎭 **오디언스별 최적화**: 발표 대상에 맞춘 내용과 톤 자동 조정
-    - 📝 **간결한 명사형 텍스트**: "~임", "~함" 스타일의 프로페셔널한 문체
-    - 🎨 **이모지 자동 추가**: 각 포인트별 적절한 이모지로 시각적 구분
-    - 📋 **예제 템플릿**: 버튼 클릭으로 예제 주제 불러오기
-    - 🎨 **디자인 테마**: 5가지 전문적인 디자인 테마 선택 가능
-    - 💎 **개선된 슬라이드 디자인**: 더 투명한 배경과 깔끔한 레이아웃
-    - 📊 **표지와 Thank You 슬라이드** 자동 추가
-    - 🎤 **오디언스별 발표자 노트** 자동 생성 (구어체)
-    - 📁 **파일 업로드** 지원 (PDF/CSV/TXT)
-    - 🔍 **웹 검색** 기능 (Brave Search)
-    - 🎚️ **슬라이드 수 조절** (6-20장)
-    - 🔧 **프로세스 플로우 다이어그램** 자동 생성 (한글 지원)
-    - 🎯 **사용자 정의 슬라이드**: 3-20장을 자유롭게 구성하여 나만의 프레젠테이션 제작
-    """)
-    # API 토큰 상태 확인
-    token_status = []
-    if not REPLICATE_API_TOKEN:
-        token_status.append("⚠️ RAPI_TOKEN 환경 변수가 설정되지 않았습니다.")
-    if not FRIENDLI_TOKEN:
-        token_status.append("⚠️ FRIENDLI_TOKEN 환경 변수가 설정되지 않았습니다.")
-    if not BRAVE_API_TOKEN:
-        token_status.append("ℹ️ BAPI_TOKEN이 없어 웹 검색 기능이 비활성화됩니다.")
-    if not PROCESS_FLOW_AVAILABLE:
-        token_status.append("ℹ️ process_flow_generator가 없어 프로세스 플로우 다이어그램이 비활성화됩니다.")
-    if token_status:
-        gr.Markdown("\n".join(token_status))
-    with gr.Row():
-        with gr.Column(scale=1):
-            # 예제 선택
-            with gr.Row():
-                example_btn = gr.Button("📋 예제 불러오기", size="sm", variant="secondary")
-            # 기본 입력
-            topic_input = gr.Textbox(
-                label="프레젠테이션 주제",
-                placeholder="예: AI 스타트업 투자 유치, 신제품 런칭, 디지털 전환 전략",
-                lines=2
-            )
-            # 오디언스 선택 (새로 추가)
-            audience_select = gr.Dropdown(
-                choices=list(AUDIENCE_TYPES.keys()),
-                label="🎭 발표 대상 오디언스",
-                value="일반 직원",
-                info="발표 대상에 따라 내용과 톤이 자동으로 최적화됩니다"
-            )
-            # 오디언스 설명 표시
-            audience_info = gr.Markdown()
-            # PPT 템플릿 선택
-            template_select = gr.Dropdown(
-                choices=list(PPT_TEMPLATES.keys()),
-                label="PPT 템플릿 선택",
-                value="비즈니스 제안서",
-                info="목적에 맞는 템플릿을 선택하세요"
-            )
-            # 디자인 테마 선택
-            theme_select = gr.Dropdown(
-                choices=list(DESIGN_THEMES.keys()),
-                label="디자인 테마 선택",
-                value="미니멀 라이트",
-                info="프레젠테이션의 전체적인 디자인 스타일"
-            )
-            # 테마 미리보기
-            theme_preview = gr.HTML()
-            # 슬라이드 수 선택
-            slide_count = gr.Slider(
-                minimum=6,
-                maximum=20,
-                value=8,
-                step=1,
-                label="본문 슬라이드 수 (표지와 Thank You 제외)",
-                info="생성할 본문 슬라이드 수를 선택하세요 (사용자 정의 템플릿에서는 사용되지 않음)"
-            )
-            # 파일 업로드
-            file_upload = gr.File(
-                label="참고 자료 업로드 (선택)",
-                file_types=[".pdf", ".csv", ".txt"],
-                type="filepath",
-                value=None
-            )
-            # 웹 검색 옵션
-            use_web_search = gr.Checkbox(
-                label="웹 검색 사용",
-                value=False,
-                info="Brave Search를 사용하여 최신 정보 반영"
-            )
-            # 템플릿 설명
-            template_info = gr.Markdown()
-            # 시드 값
-            seed_input = gr.Slider(
-                minimum=1,
-                maximum=100,
-                value=10,
-                step=1,
-                label="시드 값"
-            )
-            generate_btn = gr.Button("🚀 PPT 생성 시작 (AI가 모든 내용을 자동 생성)", variant="primary", size="lg")
-            # 사용 방법 안내
-            with gr.Accordion("📖 사용 방법", open=False):
-                gr.Markdown("""
-                ### 🔄 작업 순서:
-                1. **예제 불러오기** 버튼으로 샘플 주제를 로드하거나 직접 입력
-                2. **오디언스 선택**: 발표 대상에 따라 내용이 자동으로 최적화됩니다
-                3. **템플릿과 테마 선택** 후 생성 버튼 클릭
-                4. **다운로드**: 생성 완료 후 PPTX 파일 다운로드
-                ### 🎭 오디언스별 특징:
-                - **경영진/임원**: 전략적 가치, ROI, 비즈니스 임팩트 중심
-                - **투자자**: 시장 기회, 성장 가능성, 수익성 강조
-                - **기술팀**: 기술적 세부사항, 구현 방법, 성능 지표
-                - **일반 직원**: 실무적 내용, 협업 방안, 실행 계획
-                - **고객/파트너**: 고객 가치, 혜택, 성공 사례
-                - **일반 대중**: 쉬운 설명, 사용 편의성, 실질적 이점
-                ### 💡 텍스트 스타일 특징:
-                - **간결한 명사형 종결**: "~임", "~함" 또는 명사로 끝남
-                - **이모지 활용**: 각 포인트 앞에 내용 관련 이모지 자동 추가
-                - **8-12단어**: 각 불릿 포인트는 매우 간결하게 구성
-                ### 📝 사용자 정의 슬라이드:
-                - **템플릿 대신 직접 구성**: "사용자 정의" 템플릿 선택 시 활성화
-                - **3-20장 자유롭게 구성**: 슬라이더로 원하는 슬라이드 수 선택
-                - **각 슬라이드별 스타일 지정**: 16가지 스타일 중 선택
-                - **힌트 제공**: 각 슬라이드의 내용 방향을 프롬프트 힌트로 지정
-                ### 🔧 프로세스 플로우 다이어그램:
-                - **Business Workflow** 또는 **Flowchart** 스타일 선택 시 자동으로 프로세스 플로우 다이어그램 생성
-                - 한글 텍스트를 완벽하게 지원하는 다이어그램
-                - 프로세스, 의사결정, 입출력 등 다양한 노드 타입 지원
-                """)
-            # PPTX 다운로드 영역
-            with gr.Row():
-                download_file = gr.File(
-                    label="📥 생성된 PPTX 파일 다운로드",
-                    visible=True,
-                    elem_id="download-file"
-                )
-            # 사용자 정의 섹션
-            with gr.Accordion("📝 사용자 정의 슬라이드 구성", open=False, elem_id="custom_accordion") as custom_accordion:
-                gr.Markdown("템플릿을 사용하지 않고 직접 슬라이드를 구성하세요. (3-20장)")
-                # 사용자 정의 슬라이드 수 선택
-                custom_slide_count = gr.Slider(
-                    minimum=3,
-                    maximum=20,
-                    value=5,
-                    step=1,
-                    label="사용자 정의 슬라이드 수",
-                    info="생성할 사용자 정의 슬라이드 수를 선택하세요"
-                )
-                custom_slides_components = create_custom_slides_ui(initial_count=5)
-    # 상태 표시
-    status_output = gr.Markdown(
-        value="### 👆 템플릿을 선택하고 생성 버튼을 클릭하세요!"
-    )
-    # 프리뷰 영역
-    preview_output = gr.HTML(
-        label="PPT 프리뷰 (16:9)",
-        elem_classes="preview-container"
-    )
-    # 이벤트 핸들러
-    def load_example(template_name):
-        """템플릿에 맞는 예제 주제 로드"""
-        example_topic = EXAMPLE_TOPICS.get(template_name, "")
-        return example_topic
-    def update_audience_info(audience_type):
-        """오디언스 정보 표시"""
-        info = AUDIENCE_TYPES.get(audience_type, {})
-        return f"""**{info.get('description', '')}**
-- 톤: {info.get('tone', '')}
-- 포커스: {info.get('focus', '')}"""
-    def update_theme_preview(theme_name):
-        """테마 미리보기 HTML 생성"""
-        theme = DESIGN_THEMES.get(theme_name, DESIGN_THEMES["미니멀 라이트"])
-        # RGB 값을 hex로 변환
-        def rgb_to_hex(rgb_color):
-            return f"#{rgb_color[0]:02x}{rgb_color[1]:02x}{rgb_color[2]:02x}"
-        bg_hex = rgb_to_hex(theme["background"])
-        box_hex = rgb_to_hex(theme["box_fill"])
-        title_hex = rgb_to_hex(theme["title_color"])
-        text_hex = rgb_to_hex(theme["text_color"])
-        accent_hex = rgb_to_hex(theme["accent_color"])
-        preview_html = f"""
-        <div style="
-            background: {bg_hex};
-            padding: 20px;
-            border-radius: 8px;
-            margin: 10px 0;
-        ">
-            <div style="
-                background: {box_hex};
-                opacity: {theme['box_opacity']};
-                padding: 15px;
-                border-radius: 12px;
-                margin-bottom: 10px;
-                {'box-shadow: 0 4px 8px rgba(0,0,0,0.1);' if theme['shadow'] else ''}
-            ">
-                <h4 style="color: {title_hex}; margin: 0 0 10px 0;">{theme['name']}</h4>
-                <p style="color: {text_hex}; margin: 0; font-size: 14px;">
-                    {theme['description']}
-                </p>
-                <div style="
-                    width: 40px;
-                    height: 4px;
-                    background: {accent_hex};
-                    margin-top: 10px;
-                    border-radius: 2px;
-                "></div>
-            </div>
-        </div>
-        """
-        return preview_html
-    def update_template_info(template_name, slide_count):
-        is_custom = template_name == "사용자 정의"
-        info = ""
-        if not is_custom and template_name in PPT_TEMPLATES:
-            template = PPT_TEMPLATES[template_name]
-            info = f"**{template['description']}**\n\n"
-            # 동적으로 생성될 슬라이드 구성 표시
-            slides = generate_dynamic_slides("", template, slide_count)
-            info += f"생성될 슬라이드 ({len(slides)}장):\n"
-            for i, slide in enumerate(slides):
-                style_info = STYLE_TEMPLATES.get(slide['style'], {})
-                info += f"{i+1}. {slide['title']} - {style_info.get('use_case', '')}"
-                if style_info.get('is_process_flow'):
-                    info += " 🔧"
-                info += "\n"
-        elif is_custom:
-            info = "**사용자 정의 템플릿**\n\n아래 '사용자 정의 슬라이드 구성' 섹션에서 직접 슬라이드를 구성하세요."
-        # 사용자 정의 템플릿일 때 슬라이드 수 선택 숨기기
-        slide_count_visible = not is_custom
-        custom_accordion_open = is_custom
-        return info, gr.update(visible=slide_count_visible), gr.update(open=custom_accordion_open)
-    def update_custom_slides_visibility(count):
-        """사용자 정의 슬라이드 수에 따라 UI 표시/숨김"""
-        updates = []
-        for i in range(20):
-            updates.append(gr.update(visible=(i < count)))  # row
-        return updates
-    def generate_ppt_handler(topic, template_name, audience_type, theme_name, slide_count, seed, file_upload,
-                           use_web_search, custom_slide_count, progress=gr.Progress(),
-                           *custom_inputs):
-        if not topic.strip():
-            yield "", "❌ 주제를 입력해주세요.", None
-            return
-        # 사용자 정의 슬라이드 처리
-        custom_slides = []
-        if template_name == "사용자 정의":
-            for i in range(0, custom_slide_count * 3, 3):
-                if i < len(custom_inputs):
-                    title = custom_inputs[i]
-                    style = custom_inputs[i+1] if i+1 < len(custom_inputs) else None
-                    hint = custom_inputs[i+2] if i+2 < len(custom_inputs) else ""
-                    if title and style:
-                        custom_slides.append({
-                            "title": title,
-                            "style": style,
-                            "prompt_hint": hint
-                        })
-        # PPT 생성
-        for preview, status, pptx_file in generate_ppt_with_content(
-            topic, template_name, audience_type, custom_slides, slide_count, seed,
-            file_upload, use_web_search, theme_name, progress
-        ):
-            yield preview, status, pptx_file
-    # 이벤트 연결
-    example_btn.click(
-        fn=load_example,
-        inputs=[template_select],
-        outputs=[topic_input]
-    )
-    audience_select.change(
-        fn=update_audience_info,
-        inputs=[audience_select],
-        outputs=[audience_info]
-    )
-    theme_select.change(
-        fn=update_theme_preview,
-        inputs=[theme_select],
-        outputs=[theme_preview]
-    )
-    template_select.change(
-        fn=update_template_info,
-        inputs=[template_select, slide_count],
-        outputs=[template_info, slide_count, custom_accordion]
-    )
-    slide_count.change(
-        fn=lambda t, s: update_template_info(t, s)[0],
-        inputs=[template_select, slide_count],
-        outputs=[template_info]
-    )
-    custom_slide_count.change(
-        fn=update_custom_slides_visibility,
-        inputs=[custom_slide_count],
-        outputs=[slide["row"] for slide in custom_slides_components]
-    )
-    # 사용자 정의 슬라이드 입력 컴포넌트 평탄화
-    all_custom_inputs = []
-    for slide in custom_slides_components:
-        all_custom_inputs.extend([slide["title"], slide["style"], slide["hint"]])
-    generate_btn.click(
-        fn=generate_ppt_handler,
-        inputs=[
-            topic_input, template_select, audience_select, theme_select, slide_count,
-            seed_input, file_upload, use_web_search, custom_slide_count
-        ] + all_custom_inputs,
-        outputs=[preview_output, status_output, download_file]
-    )
-    # 초기 로드시 템플릿/테마 정보 표시
-    demo.load(
-        fn=lambda: (update_template_info(template_select.value, slide_count.value)[0],
-                   update_theme_preview(theme_select.value),
-                   update_audience_info(audience_select.value)),
-        inputs=[],
-        outputs=[template_info, theme_preview, audience_info]
-    )
-# 앱 실행
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)

 import os
+import sys
+import streamlit as st
+from tempfile import NamedTemporaryFile
+def main():
     try:
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
+        if not code:
+            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            return
+        # Create a temporary Python file
+        with NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
+        # Execute the code
+        exec(compile(code, tmp_path, 'exec'), globals())
+        # Clean up the temporary file
         try:
+            os.unlink(tmp_path)
+        except:
+            pass
     except Exception as e:
+        st.error(f"⚠️ Error loading or executing the application: {str(e)}")
+        import traceback
+        st.code(traceback.format_exc())
 if __name__ == "__main__":
+    main()