Update app.py

app.py

@@ -1,893 +1,26 @@
-# ──────────────────────────────── Imports ────────────────────────────────
-import os, json, re, logging, requests, markdown, time, io
-from datetime import datetime
-
 import streamlit as st
-from openai import OpenAI  # OpenAI 라이브러리
-
-from gradio_client import Client
-import pandas as pd
-import PyPDF2  # For handling PDF files
-
-# ──────────────────────────────── Environment Variables / Constants ─────────────────────────
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")  
-BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # Keep this name
-BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
-IMAGE_API_URL  = "http://211.233.58.201:7896"
-MAX_TOKENS     = 7999
-
-# Blog template and style definitions (in English)
-BLOG_TEMPLATES = {
-    "ginigen": "Recommended style by Ginigen",
-    "standard": "Standard 8-step framework blog",
-    "tutorial": "Step-by-step tutorial format",
-    "review": "Product/service review format",
-    "storytelling": "Storytelling format",
-    "seo_optimized": "SEO-optimized blog"
-}
-
-BLOG_TONES = {
-    "professional": "Professional and formal tone",
-    "casual": "Friendly and conversational tone",
-    "humorous": "Humorous approach",
-    "storytelling": "Story-driven approach"
-}
-
-# Example blog topics
-EXAMPLE_TOPICS = {
-    "example1": "Changes to the real estate tax system in 2025: Impact on average households and tax-saving strategies",
-    "example2": "Summer festivals in 2025: A comprehensive guide to major regional events and hidden attractions",
-    "example3": "Emerging industries to watch in 2025: An investment guide focused on AI opportunities"
-}
-
-# ──────────────────────────────── Logging ────────────────────────────────
-logging.basicConfig(level=logging.INFO,
-                    format="%(asctime)s - %(levelname)s - %(message)s")
-
-# ──────────────────────────────── OpenAI Client ──────────────────────────
-
-# OpenAI 클라이언트에 타임아웃과 재시도 로직 추가
-@st.cache_resource
-def get_openai_client():
-    """Create an OpenAI client with timeout and retry settings."""
-    if not OPENAI_API_KEY:
-        raise RuntimeError("⚠️ OPENAI_API_KEY 환경 변수가 설정되지 않았습니다.")
-    return OpenAI(
-        api_key=OPENAI_API_KEY,
-        timeout=60.0,  # 타임아웃 60초로 설정
-        max_retries=3  # 재시도 횟수 3회로 설정
-    )
-    
-# ──────────────────────────────── Blog Creation System Prompt ─────────────
-def get_system_prompt(template="ginigen", tone="professional", word_count=1750, include_search_results=False, include_uploaded_files=False) -> str:
-    """
-    Generate a system prompt that includes:
-    - The 8-step blog writing framework
-    - The selected template and tone
-    - Guidelines for using web search results and uploaded files
-    """
-
-    # Ginigen recommended style prompt (English version)
-    ginigen_prompt = """
-You are an expert English SEO copywriter.
-◆ Purpose
-- Create a blog post based on the given YouTube video script that captivates both search engines and readers.
-- Always follow the 4 writing principles: **[Lead with the main point → Keep it simple and short → Emphasize reader benefits → Call to action]**.
-◆ Complete Format (Use markdown, avoid unnecessary explanations)
-1. **Title**
-  - Emoji + Curiosity question/exclamation + Core keywords (Within 70 characters)
-  - Example: `# 🧬 Can Reducing Inflammation Help You Lose Weight?! 5 Amazing Benefits of Quercetin`
-2. **Hook (2-3 lines)**
-  - Present problem → Mention solution keyword → Summarize the benefit of reading this post
-3. `---` Divider
-4. **Section 1: Core Concept Introduction**
-  - `## 🍏 What is [Keyword]?`
-  - 1-2 paragraphs definition + 📌 One-line summary
-5. `---`
-6. **Section 2: 5 Benefits/Reasons**
-  - `## 💪 5 Reasons Why [Keyword] Is Beneficial`
-  - Each subsection format:
-  
-### 1. [Keyword-focused subheading]
-1-2 paragraphs explanation
-> ✔ One-line key point emphasis
-- Total of 5 items
-7. **Section 3: Consumption/Usage Methods**
-- `## 🥗 How to Use [Keyword] Effectively!`
-- Emoji bullet list of around 5 items + Additional tips
-8. `---`
-9. **Concluding Call to Action**
-- `## 📌 Conclusion – Start Using [Keyword] Today!`
-- 2-3 sentences on benefits/changes → **Action directive** (purchase, subscribe, share, etc.)
-10. `---`
-11. **Key Summary Table**
- | Item | Effect |
- |---|---|
- | [Keyword] | [Effect summary] |
- | Key foods/products | [List] |
-12. `---`
-13. **Quiz & CTA**
- - Simple Q&A quiz (1 question) → Reveal answer
- - "If you found this helpful, please share/comment" phrase
- - Preview of next post
-◆ Additional Guidelines
-- Total length 1,200-1,800 words.
-- Use simple vocabulary and short sentences, enhance readability with emojis, bold text, and quoted sections.
-- Increase credibility with specific numbers, research results, and analogies.
-- No meta-mentions of "prompts" or "instructions".
-- Use conversational but professional tone throughout.
-- Minimize expressions like "according to research" if no external sources are provided.
-◆ Output
-- Return **only the completed blog post** in the above format. No additional text.  
-"""
-
-    # Standard 8-step framework (English version)
-    base_prompt = """
-You are an expert in writing professional blog posts. For every blog writing request, strictly follow this 8-step framework to produce a coherent, engaging post:
-
-Reader Connection Phase
-1.1. Friendly greeting to build rapport
-1.2. Reflect actual reader concerns through introductory questions
-1.3. Stimulate immediate interest in the topic
-
-Problem Definition Phase
-2.1. Define the reader's pain points in detail
-2.2. Analyze the urgency and impact of the problem
-2.3. Build a consensus on why it needs to be solved
-
-Establish Expertise Phase
-3.1. Analyze based on objective data
-3.2. Cite expert views and research findings
-3.3. Use real-life examples to further clarify the issue
-
-Solution Phase
-4.1. Provide step-by-step guidance
-4.2. Suggest practical tips that can be applied immediately
-4.3. Mention potential obstacles and how to overcome them
-
-Build Trust Phase
-5.1. Present actual success stories
-5.2. Quote real user feedback
-5.3. Use objective data to prove effectiveness
-
-Action Phase
-6.1. Suggest the first clear step the reader can take
-6.2. Urge timely action by emphasizing urgency
-6.3. Motivate by highlighting incentives or benefits
-
-Authenticity Phase
-7.1. Transparently disclose any limits of the solution
-7.2. Admit that individual experiences may vary
-7.3. Mention prerequisites or cautionary points
-
-Relationship Continuation Phase
-8.1. Conclude with sincere gratitude
-8.2. Preview upcoming content to build anticipation
-8.3. Provide channels for further communication
-"""
-
-    # Additional guidelines for each template
-    template_guides = {
-        "tutorial": """
-This blog should be in a tutorial style:
-- Clearly state the goal and the final outcome first
-- Provide step-by-step explanations with clear separations
-- Indicate where images could be inserted for each step
-- Mention approximate time requirements and difficulty level
-- List necessary tools or prerequisite knowledge
-- Give troubleshooting tips and common mistakes to avoid
-- Conclude with suggestions for next steps or advanced applications
-""",
-        "review": """
-This blog should be in a review style:
-- Separate objective facts from subjective opinions
-- Clearly list your evaluation criteria
-- Discuss both pros and cons in a balanced way
-- Compare with similar products/services
-- Specify the target audience for whom it is suitable
-- Provide concrete use cases and outcomes
-- Conclude with a final recommendation or alternatives
-""",
-        "storytelling": """
-This blog should be in a storytelling style:
-- Start with a real or hypothetical person or case
-- Emphasize emotional connection with the problem scenario
-- Follow a narrative structure centered on conflict and resolution
-- Include meaningful insights or lessons learned
-- Maintain an emotional thread the reader can relate to
-- Balance storytelling with useful information
-- Encourage the reader to reflect on their own story
-""",
-        "seo_optimized": """
-This blog should be SEO-optimized:
-- Include the main keyword in the title, headings, and first paragraph
-- Spread related keywords naturally throughout the text
-- Keep paragraphs around 300-500 characters
-- Use question-based subheadings
-- Make use of lists, tables, and bold text to diversify formatting
-- Indicate where internal links could be inserted
-- Provide sufficient content of at least 2000-3000 characters
-"""
-    }
-
-    # Additional guidelines for each tone
-    tone_guides = {
-        "professional": "Use a professional, authoritative voice. Clearly explain any technical terms and present data or research to maintain a logical flow.",
-        "casual": "Use a relaxed, conversational style. Employ personal experiences, relatable examples, and a friendly voice (e.g., 'It's super useful!').",
-        "humorous": "Use humor and witty expressions. Add funny analogies or jokes while preserving accuracy and usefulness.",
-        "storytelling": "Write as if telling a story, with emotional depth and narrative flow. Incorporate characters, settings, conflicts, and resolutions."
-    }
-
-    # Guidelines for using search results
-    search_guide = """
-Guidelines for Using Search Results:
-- Accurately incorporate key information from the search results into the blog
-- Include recent data, statistics, and case studies from the search results
-- When quoting, specify the source within the text (e.g., "According to XYZ website...")
-- At the end of the blog, add a "References" section and list major sources with links
-- If there are conflicting pieces of information, present multiple perspectives
-- Make sure to reflect the latest trends and data from the search results
-"""
-
-    # Guidelines for using uploaded files
-    upload_guide = """
-Guidelines for Using Uploaded Files (Highest Priority):
-- The uploaded files must be a main source of information for the blog
-- Carefully examine the data, statistics, or examples in the file and integrate them
-- Directly quote and thoroughly explain any key figures or claims from the file
-- Highlight the file content as a crucial aspect of the blog
-- Mention the source clearly, e.g., "According to the uploaded data..."
-- For CSV files, detail important stats or numerical data in the blog
-- For PDF files, quote crucial segments or statements
-- For text files, integrate relevant content effectively
-- Even if the file content seems tangential, do your best to connect it to the blog topic
-- Keep consistency throughout and ensure the file's data is appropriately reflected
-"""
-
-    # Choose base prompt
-    if template == "ginigen":
-        final_prompt = ginigen_prompt
-    else:
-        final_prompt = base_prompt
-
-    # If the user chose a specific template (and not ginigen), append the relevant guidelines
-    if template != "ginigen" and template in template_guides:
-        final_prompt += "\n" + template_guides[template]
-
-    # If a specific tone is selected, append that guideline
-    if tone in tone_guides:
-        final_prompt += f"\n\nTone and Manner: {tone_guides[tone]}"
+import os
+import base64
+import types
 
-    # If web search results should be included
-    if include_search_results:
-        final_prompt += f"\n\n{search_guide}"
+# Secret에서 저장된 코드 가져오기
+app_code = os.environ.get("APP", "")
 
-    # If uploaded files should be included
-    if include_uploaded_files:
-        final_prompt += f"\n\n{upload_guide}"
-
-    # Word count guidelines
-    final_prompt += (
-        f"\n\nWriting Requirements:\n"
-        f"9.1. Word Count: around {word_count-250}-{word_count+250} characters\n"
-        f"9.2. Paragraph Length: 3-4 sentences each\n"
-        f"9.3. Visual Cues: Use subheadings, separators, and bullet/numbered lists\n"
-        f"9.4. Data: Cite all sources\n"
-        f"9.5. Readability: Use clear paragraph breaks and highlights where necessary"
-    )
-
-    return final_prompt
-
-# ──────────────────────────────── Brave Search API ────────────────────────
-@st.cache_data(ttl=3600)
-def brave_search(query: str, count: int = 20):
-    """
-    Call the Brave Web Search API → list[dict]
-    Returns fields: index, title, link, snippet, displayed_link
-    """
-    if not BRAVE_KEY:
-        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
-
-    headers = {
-        "Accept": "application/json",
-        "Accept-Encoding": "gzip",
-        "X-Subscription-Token": BRAVE_KEY
-    }
-    params = {"q": query, "count": str(count)}
-
-    for attempt in range(3):
-        try:
-            r = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
-            r.raise_for_status()
-            data = r.json()
-
-            logging.info(f"Brave search result data structure: {list(data.keys())}")
-
-            raw = data.get("web", {}).get("results") or data.get("results", [])
-            if not raw:
-                logging.warning(f"No Brave search results found. Response: {data}")
-                raise ValueError("No search results found.")
-            
-            arts = []
-            for i, res in enumerate(raw[:count], 1):
-                url = res.get("url", res.get("link", ""))
-                host = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
-                arts.append({
-                    "index": i,
-                    "title": res.get("title", "No title"),
-                    "link": url,
-                    "snippet": res.get("description", res.get("text", "No snippet")),
-                    "displayed_link": host
-                })
-
-            logging.info(f"Brave search success: {len(arts)} results")
-            return arts
-
-        except Exception as e:
-            logging.error(f"Brave search failure (attempt {attempt+1}/3): {e}")
-            if attempt < 2:
-                time.sleep(2)
-
-    return []
-
-def mock_results(query: str) -> str:
-    """Fallback search results if API fails"""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    return (f"# Fallback Search Content (Generated: {ts})\n\n"
-            f"The search API request failed. Please generate the blog based on any pre-existing knowledge about '{query}'.\n\n"
-            f"You may consider the following points:\n\n"
-            f"- Basic concepts and importance of {query}\n"
-            f"- Commonly known related statistics or trends\n"
-            f"- Typical expert opinions on this subject\n"
-            f"- Questions that readers might have\n\n"
-            f"Note: This is fallback guidance, not real-time data.\n\n")
-
-def do_web_search(query: str) -> str:
-    """Perform web search and format the results."""
+# 코드 실행 함수
+def execute_code(code_str):
     try:
-        arts = brave_search(query, 20)
-        if not arts:
-            logging.warning("No search results, using fallback content")
-            return mock_results(query)
-
-        hdr = "# Web Search Results\nUse the information below to enhance the reliability of your blog. When you quote, please cite the source, and add a References section at the end of the blog.\n\n"
-        body = "\n".join(
-            f"### Result {a['index']}: {a['title']}\n\n{a['snippet']}\n\n"
-            f"**Source**: [{a['displayed_link']}]({a['link']})\n\n---\n"
-            for a in arts
-        )
-        return hdr + body
-    except Exception as e:
-        logging.error(f"Web search process failed: {str(e)}")
-        return mock_results(query)
-
-# ──────────────────────────────── File Upload Handling ─────────────────────
-def process_text_file(file):
-    """Handle text file"""
-    try:
-        content = file.read()
-        file.seek(0)
-
-        text = content.decode('utf-8', errors='ignore')
-        if len(text) > 10000:
-            text = text[:9700] + "...(truncated)..."
-
-        result = f"## Text File: {file.name}\n\n"
-        result += text
-        return result
-    except Exception as e:
-        logging.error(f"Error processing text file: {str(e)}")
-        return f"Error processing text file: {str(e)}"
-
-def process_csv_file(file):
-    """Handle CSV file"""
-    try:
-        content = file.read()
-        file.seek(0)
-
-        df = pd.read_csv(io.BytesIO(content))
-        result = f"## CSV File: {file.name}\n\n"
-        result += f"- Rows: {len(df)}\n"
-        result += f"- Columns: {len(df.columns)}\n"
-        result += f"- Column Names: {', '.join(df.columns.tolist())}\n\n"
-
-        result += "### Data Preview\n\n"
-        preview_df = df.head(10)
-        try:
-            markdown_table = preview_df.to_markdown(index=False)
-            if markdown_table:
-                result += markdown_table + "\n\n"
-            else:
-                result += "Unable to display CSV data.\n\n"
-        except Exception as e:
-            logging.error(f"Markdown table conversion error: {e}")
-            result += "Displaying data as text:\n\n"
-            result += str(preview_df) + "\n\n"
-
-        num_cols = df.select_dtypes(include=['number']).columns
-        if len(num_cols) > 0:
-            result += "### Basic Statistical Information\n\n"
-            try:
-                stats_df = df[num_cols].describe().round(2)
-                stats_markdown = stats_df.to_markdown()
-                if stats_markdown:
-                    result += stats_markdown + "\n\n"
-                else:
-                    result += "Unable to display statistical information.\n\n"
-            except Exception as e:
-                logging.error(f"Statistical info conversion error: {e}")
-                result += "Unable to generate statistical information.\n\n"
-
-        return result
-    except Exception as e:
-        logging.error(f"CSV file processing error: {str(e)}")
-        return f"Error processing CSV file: {str(e)}"
-
-def process_pdf_file(file):
-    """Handle PDF file"""
-    try:
-        # Read file in bytes
-        file_bytes = file.read()
-        file.seek(0)
-
-        # Use PyPDF2
-        pdf_file = io.BytesIO(file_bytes)
-        reader = PyPDF2.PdfReader(pdf_file, strict=False)
-
-        # Basic info
-        result = f"## PDF File: {file.name}\n\n"
-        result += f"- Total pages: {len(reader.pages)}\n\n"
-
-        # Extract text by page (limit to first 5 pages)
-        max_pages = min(5, len(reader.pages))
-        all_text = ""
-
-        for i in range(max_pages):
-            try:
-                page = reader.pages[i]
-                page_text = page.extract_text()
-
-                current_page_text = f"### Page {i+1}\n\n"
-                if page_text and len(page_text.strip()) > 0:
-                    # Limit to 1500 characters per page
-                    if len(page_text) > 1500:
-                        current_page_text += page_text[:1500] + "...(truncated)...\n\n"
-                    else:
-                        current_page_text += page_text + "\n\n"
-                else:
-                    current_page_text += "(No text could be extracted from this page)\n\n"
-
-                all_text += current_page_text
-
-                # If total text is too long, break
-                if len(all_text) > 8000:
-                    all_text += "...(truncating remaining pages; PDF is too large)...\n\n"
-                    break
-
-            except Exception as page_err:
-                logging.error(f"Error processing PDF page {i+1}: {str(page_err)}")
-                all_text += f"### Page {i+1}\n\n(Error extracting content: {str(page_err)})\n\n"
-
-        if len(reader.pages) > max_pages:
-            all_text += f"\nNote: Only the first {max_pages} pages are shown out of {len(reader.pages)} total.\n\n"
-
-        result += "### PDF Content\n\n" + all_text
-        return result
-
-    except Exception as e:
-        logging.error(f"PDF file processing error: {str(e)}")
-        return f"## PDF File: {file.name}\n\nError occurred: {str(e)}\n\nThis PDF file cannot be processed."
-
-def process_uploaded_files(files):
-    """Combine the contents of all uploaded files into one string."""
-    if not files:
-        return None
-
-    result = "# Uploaded File Contents\n\n"
-    result += "Below is the content from the files provided by the user. Integrate this data as a main source of information for the blog.\n\n"
-
-    for file in files:
-        try:
-            ext = file.name.split('.')[-1].lower()
-            if ext == 'txt':
-                result += process_text_file(file) + "\n\n---\n\n"
-            elif ext == 'csv':
-                result += process_csv_file(file) + "\n\n---\n\n"
-            elif ext == 'pdf':
-                result += process_pdf_file(file) + "\n\n---\n\n"
-            else:
-                result += f"### Unsupported File: {file.name}\n\n---\n\n"
-        except Exception as e:
-            logging.error(f"File processing error {file.name}: {e}")
-            result += f"### File processing error: {file.name}\n\nError: {e}\n\n---\n\n"
-
-    return result
-
-# ──────────────────────────────── Image & Utility ─────────────────────────
-def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
-    """Image generation function."""
-    if not prompt:
-        return None, "Insufficient prompt"
-    try:
-        res = Client(IMAGE_API_URL).predict(
-            prompt=prompt, width=w, height=h, guidance=g,
-            inference_steps=steps, seed=seed,
-            do_img2img=False, init_image=None,
-            image2image_strength=0.8, resize_img=True,
-            api_name="/generate_image"
-        )
-        return res[0], f"Seed: {res[1]}"
-    except Exception as e:
-        logging.error(e)
-        return None, str(e)
-
-def extract_image_prompt(blog_text: str, topic: str):
-    """
-    Generate a single-line English image prompt from the blog content.
-    """
-    client = get_openai_client()
-    
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4.1-mini",  # 일반적으로 사용 가능한 모델로 설정
-            messages=[
-                {"role": "system", "content": "Generate a single-line English image prompt from the following text. Return only the prompt text, nothing else."},
-                {"role": "user", "content": f"Topic: {topic}\n\n---\n{blog_text}\n\n---"}
-            ],
-            temperature=1,
-            max_tokens=80,
-            top_p=1
-        )
+        # 실행 가능한 코드로 변환
+        code_module = types.ModuleType('dynamic_code')
+        exec(code_str, code_module.__dict__)
         
-        return response.choices[0].message.content.strip()
+        # 필요한 함수 실행
+        if hasattr(code_module, 'main'):
+            code_module.main()
     except Exception as e:
-        logging.error(f"OpenAI image prompt generation error: {e}")
-        return f"A professional photo related to {topic}, high quality"
-
-def md_to_html(md: str, title="Ginigen Blog"):
-    """Convert Markdown to HTML."""
-    return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"
-
-def keywords(text: str, top=5):
-    """Simple keyword extraction."""
-    cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
-    return " ".join(cleaned.split()[:top])
-
-# ──────────────────────────────── Streamlit UI ────────────────────────────
-def ginigen_app():
-    st.title("Ginigen Blog")
-
-    # Set default session state
-    if "ai_model" not in st.session_state:
-        st.session_state.ai_model = "gpt-4.1-mini"  # 고정 모델 설정
-    if "messages" not in st.session_state:
-        st.session_state.messages = []
-    if "auto_save" not in st.session_state:
-        st.session_state.auto_save = True
-    if "generate_image" not in st.session_state:
-        st.session_state.generate_image = False
-    if "web_search_enabled" not in st.session_state:
-        st.session_state.web_search_enabled = True
-    if "blog_template" not in st.session_state:
-        st.session_state.blog_template = "ginigen"  # Ginigen recommended style by default
-    if "blog_tone" not in st.session_state:
-        st.session_state.blog_tone = "professional"
-    if "word_count" not in st.session_state:
-        st.session_state.word_count = 1750
-
-    # Sidebar UI
-    sb = st.sidebar
-    sb.title("Blog Settings")
-    
-    # 모델 선택 제거 (고정 모델 사용)
-    
-    sb.subheader("Blog Style Settings")
-    sb.selectbox(
-        "Blog Template", 
-        options=list(BLOG_TEMPLATES.keys()), 
-        format_func=lambda x: BLOG_TEMPLATES[x],
-        key="blog_template"
-    )
-    
-    sb.selectbox(
-        "Blog Tone",
-        options=list(BLOG_TONES.keys()),
-        format_func=lambda x: BLOG_TONES[x],
-        key="blog_tone"
-    )
-    
-    sb.slider("Blog Length (word count)", 800, 3000, key="word_count")
-
-    
-    # Example topics
-    sb.subheader("Example Topics")
-    c1, c2, c3 = sb.columns(3)
-    if c1.button("Real Estate Tax", key="ex1"):
-        process_example(EXAMPLE_TOPICS["example1"])
-    if c2.button("Summer Festivals", key="ex2"):
-        process_example(EXAMPLE_TOPICS["example2"])
-    if c3.button("Investment Guide", key="ex3"):
-        process_example(EXAMPLE_TOPICS["example3"])
-    
-    sb.subheader("Other Settings")
-    sb.toggle("Auto Save", key="auto_save")
-    sb.toggle("Auto Image Generation", key="generate_image")
-    
-    web_search_enabled = sb.toggle("Use Web Search", value=st.session_state.web_search_enabled)
-    st.session_state.web_search_enabled = web_search_enabled
-    
-    if web_search_enabled:
-        st.sidebar.info("✅ Web search results will be integrated into the blog.")
-
-    # Download the latest blog (markdown/HTML)
-    latest_blog = next(
-        (m["content"] for m in reversed(st.session_state.messages) 
-         if m["role"] == "assistant" and m["content"].strip()), 
-        None
-    )
-    if latest_blog:
-        title_match = re.search(r"# (.*?)(\n|$)", latest_blog)
-        title = title_match.group(1).strip() if title_match else "blog"
-        sb.subheader("Download Latest Blog")
-        d1, d2 = sb.columns(2)
-        d1.download_button("Download as Markdown", latest_blog, 
-                           file_name=f"{title}.md", mime="text/markdown")
-        d2.download_button("Download as HTML", md_to_html(latest_blog, title),
-                           file_name=f"{title}.html", mime="text/html")
-
-    # JSON conversation record upload
-    up = sb.file_uploader("Load Conversation History (.json)", type=["json"], key="json_uploader")
-    if up:
-        try:
-            st.session_state.messages = json.load(up)
-            sb.success("Conversation history loaded successfully")
-        except Exception as e:
-            sb.error(f"Failed to load: {e}")
-
-    # JSON conversation record download
-    if sb.button("Download Conversation as JSON"):
-        sb.download_button(
-            "Save",
-            data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
-            file_name="chat_history.json",
-            mime="application/json"
-        )
-
-    # File Upload
-    st.subheader("File Upload")
-    uploaded_files = st.file_uploader(
-        "Upload files to be referenced in your blog (txt, csv, pdf)",
-        type=["txt", "csv", "pdf"],
-        accept_multiple_files=True,
-        key="file_uploader"
-    )
-    
-    if uploaded_files:
-        file_count = len(uploaded_files)
-        st.success(f"{file_count} files uploaded. They will be referenced in the blog.")
-        
-        with st.expander("Preview Uploaded Files", expanded=False):
-            for idx, file in enumerate(uploaded_files):
-                st.write(f"**File Name:** {file.name}")
-                ext = file.name.split('.')[-1].lower()
-                
-                if ext == 'txt':
-                    preview = file.read(1000).decode('utf-8', errors='ignore')
-                    file.seek(0)
-                    st.text_area(
-                        f"Preview of {file.name}",
-                        preview + ("..." if len(preview) >= 1000 else ""),
-                        height=150
-                    )
-                elif ext == 'csv':
-                    try:
-                        df = pd.read_csv(file)
-                        file.seek(0)
-                        st.write("CSV Preview (up to 5 rows)")
-                        st.dataframe(df.head(5))
-                    except Exception as e:
-                        st.error(f"CSV preview failed: {e}")
-                elif ext == 'pdf':
-                    try:
-                        file_bytes = file.read()
-                        file.seek(0)
-                        
-                        pdf_file = io.BytesIO(file_bytes)
-                        reader = PyPDF2.PdfReader(pdf_file, strict=False)
-                        
-                        pc = len(reader.pages)
-                        st.write(f"PDF File: {pc} pages")
-                        
-                        if pc > 0:
-                            try:
-                                page_text = reader.pages[0].extract_text()
-                                preview = page_text[:500] if page_text else "(No text extracted)"
-                                st.text_area("Preview of the first page", preview + "...", height=150)
-                            except:
-                                st.warning("Failed to extract text from the first page")
-                    except Exception as e:
-                        st.error(f"PDF preview failed: {e}")
-
-                if idx < file_count - 1:
-                    st.divider()
-
-    # Display existing messages
-    for m in st.session_state.messages:
-        with st.chat_message(m["role"]):
-            st.markdown(m["content"])
-            if "image" in m:
-                st.image(m["image"], caption=m.get("image_caption", ""))
-
-    # User input
-    prompt = st.chat_input("Enter a blog topic or keywords.")
-    if prompt:
-        process_input(prompt, uploaded_files)
-
-def process_example(topic):
-    """Process the selected example topic."""
-    process_input(topic, [])
-
-def process_input(prompt: str, uploaded_files):
-    # Add user's message
-    if not any(m["role"] == "user" and m["content"] == prompt for m in st.session_state.messages):
-        st.session_state.messages.append({"role": "user", "content": prompt})
-
-    with st.chat_message("user"):
-        st.markdown(prompt)
-    
-    with st.chat_message("assistant"):
-        placeholder = st.empty()
-        message_placeholder = st.empty()
-        full_response = ""
-
-        use_web_search = st.session_state.web_search_enabled
-        has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
-        
-        try:
-            # 상태 표시를 위한 상태 컴포넌트
-            status = st.status("Preparing to generate blog...")
-            status.update(label="Initializing client...")
-            
-            client = get_openai_client()
-            
-            # Prepare conversation messages
-            messages = []
-            
-            # Web search
-            search_content = None
-            if use_web_search:
-                status.update(label="Performing web search...")
-                with st.spinner("Searching the web..."):
-                    search_content = do_web_search(keywords(prompt, top=5))
-            
-            # Process uploaded files → content
-            file_content = None
-            if has_uploaded_files:
-                status.update(label="Processing uploaded files...")
-                with st.spinner("Analyzing files..."):
-                    file_content = process_uploaded_files(uploaded_files)
-            
-            # Build system prompt
-            status.update(label="Preparing blog draft...")
-            sys_prompt = get_system_prompt(
-                template=st.session_state.blog_template,
-                tone=st.session_state.blog_tone,
-                word_count=st.session_state.word_count,
-                include_search_results=use_web_search,
-                include_uploaded_files=has_uploaded_files
-            )
-
-            # OpenAI API 호출 준비
-            status.update(label="Writing blog content...")
-            
-            # 메시지 구성
-            api_messages = [
-                {"role": "system", "content": sys_prompt}
-            ]
-            
-            user_content = prompt
-            
-            # 검색 결과가 있으면 사용자 프롬프트에 추가
-            if search_content:
-                user_content += "\n\n" + search_content
-            
-            # 파일 내용이 있으면 사용자 프롬프트에 추가
-            if file_content:
-                user_content += "\n\n" + file_content
-            
-            # 사용자 메시지 추가
-            api_messages.append({"role": "user", "content": user_content})
-            
-            # OpenAI API 스트리밍 호출 - 고정 모델 "gpt-4.1-mini" 사용
-            try:
-                # 스트리밍 방식으로 API 호출
-                stream = client.chat.completions.create(
-                    model="gpt-4.1-mini",  # 고정 모델 사용
-                    messages=api_messages,
-                    temperature=1,
-                    max_tokens=MAX_TOKENS,
-                    top_p=1,
-                    stream=True  # 스트리밍 활성화
-                )
-                
-                # 스트리밍 응답 처리
-                for chunk in stream:
-                    if chunk.choices and len(chunk.choices) > 0 and chunk.choices[0].delta.content is not None:
-                        content_delta = chunk.choices[0].delta.content
-                        full_response += content_delta
-                        message_placeholder.markdown(full_response + "▌")
-                
-                # 최종 응답 표시 (커서 제거)
-                message_placeholder.markdown(full_response)
-                status.update(label="Blog completed!", state="complete")
-                
-            except Exception as api_error:
-                error_message = str(api_error)
-                logging.error(f"API error: {error_message}")
-                status.update(label=f"Error: {error_message}", state="error")
-                raise Exception(f"Blog generation error: {error_message}")
-            
-            # 이미지 생성
-            answer_entry_saved = False
-            if st.session_state.generate_image and full_response:
-                with st.spinner("Generating image..."):
-                    try:
-                        ip = extract_image_prompt(full_response, prompt)
-                        img, cap = generate_image(ip)
-                        if img:
-                            st.image(img, caption=cap)
-                            st.session_state.messages.append({
-                                "role": "assistant",
-                                "content": full_response,
-                                "image": img,
-                                "image_caption": cap
-                            })
-                            answer_entry_saved = True
-                    except Exception as img_error:
-                        logging.error(f"Image generation error: {str(img_error)}")
-                        st.warning("이미지 생성에 실패했습니다. 블로그 콘텐츠만 저장됩니다.")
-
-            # Save the answer if not saved above
-            if not answer_entry_saved and full_response:
-                st.session_state.messages.append({"role": "assistant", "content": full_response})
-
-            # Download buttons
-            if full_response:
-                st.subheader("Download This Blog")
-                c1, c2 = st.columns(2)
-                c1.download_button(
-                    "Markdown", 
-                    data=full_response, 
-                    file_name=f"{prompt[:30]}.md",
-                    mime="text/markdown"
-                )
-                c2.download_button(
-                    "HTML",
-                    data=md_to_html(full_response, prompt[:30]),
-                    file_name=f"{prompt[:30]}.html",
-                    mime="text/html"
-                )
-
-            # Auto save
-            if st.session_state.auto_save and st.session_state.messages:
-                try:
-                    fn = f"chat_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
-                    with open(fn, "w", encoding="utf-8") as fp:
-                        json.dump(st.session_state.messages, fp, ensure_ascii=False, indent=2)
-                except Exception as e:
-                    logging.error(f"Auto-save failed: {e}")
-
-        except Exception as e:
-            error_message = str(e)
-            placeholder.error(f"An error occurred: {error_message}")
-            logging.error(f"Process input error: {error_message}")
-            ans = f"An error occurred while processing your request: {error_message}"
-            st.session_state.messages.append({"role": "assistant", "content": ans})
-
-
-# ──────────────────────────────── main ────────────────────────────────────
-def main():
-    ginigen_app()
+        st.error(f"코드 실행 중 오류 발생: {str(e)}")
 
-if __name__ == "__main__":
-    main()
+# 코드 실행
+if app_code:
+    execute_code(app_code)
+else:
+    st.error("코드를 불러올 수 없습니다. Secret이 올바르게 설정되었는지 확인하세요.")