Upload 2 files

app (33).py

@@ -0,0 +1,889 @@
+# ──────────────────────────────── 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 = """
+## 🌟 Professional Blogger System Prompt
+
+### ✅ Official 8-step Prompt
+
+Follow these 8 steps exactly in order to write the blog post:
+
+### 1. Start with a greeting and empathy
+- Open with a friendly tone that draws the reader in
+- Ask questions or present scenarios that resonate with the reader's real-life concerns
+
+### 2. Clearly present the problem
+- Pinpoint the exact and realistic problem the reader is facing
+- Emphasize the seriousness or urgency of this problem to maintain interest
+
+### 3. Analyze the cause of the problem to build credibility
+- Explain the causes of the problem logically
+- Clearly and specifically present your analysis so the reader can understand it easily
+- Include data, examples, or references if necessary
+
+### 4. Offer a concrete solution
+- Provide specific, actionable steps to solve the problem
+- Give tips, strategies, and guidelines so the reader can implement them right away
+
+### 5. Provide social proof
+- Include real success stories, reviews, user experiences, or data
+- Keep details factual and believable so the reader can trust the content
+
+### 6. Call to action (CTA)
+- Encourage the reader to take specific actions immediately
+- Use urgent language such as "right now," "from today," or "immediately" to drive action
+
+### 7. Add constraints or warnings to increase authenticity
+- Acknowledge that the solution might not work for everyone
+- Show sincerity and scarcity, which boosts trust
+
+### 8. Express gratitude and guide them to further connection
+- Thank the reader for their time
+- Provide a natural lead-in to the next post, or ask for comments/subscriptions
+
+---
+
+### 🚩 Writing Style Tips
+- Maintain a friendly and human-like tone
+- Frequently use questions and a conversational style to engage the reader
+- Use clear headings, horizontal lines, bullet points, or numbered lists for readability
+- Include real-life examples and specific data where possible
+"""
+
+    # 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]}"
+
+    # If web search results should be included
+    if include_search_results:
+        final_prompt += f"\n\n{search_guide}"
+
+    # 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."""
+    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
+        )
+        
+        return response.choices[0].message.content.strip()
+    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()
+
+if __name__ == "__main__":
+    main()

requirements (14).txt

@@ -0,0 +1,16 @@
+streamlit
+anthropic
+gradio
+gradio-client
+httpx
+requests
+python-dotenv
+markdown 
+weasyprint
+beautifulsoup4>=4.12.0
+lxml>=4.9.0
+pillow
+pandas
+PyPDF2
+openai
+tabulate