Update app.py

app.py

@@ -1,1037 +1,35 @@
-# ──────────────────────────────── Imports ────────────────────────────────
-import os, json, re, logging, requests, markdown, time, io
-from datetime import datetime
-
+import os
+import sys
 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
-
-# ──────────────────────────────── Content Template Definitions ─────────────────────────
-# Only one blog version ("ginigen") plus the other specialized content prompts
-BLOG_TEMPLATES = {
-    "ginigen":     "Ginigen Blog",
-    "insta":       "Instagram Reels script",
-    "thread":      "SNS Thread post",
-    "shortform":   "60-sec Short-form video",
-    "youtube":     "YouTube script",
-    "productdesc": "제품 상세 설명서"
-}
-
-# ───────── Tone definitions (applied across all content types) ─────────
-BLOG_TONES = {
-    "professional": "Professional and formal tone",
-    "casual":       "Friendly and conversational tone",
-    "humorous":     "Humorous approach",
-    "storytelling": "Story-driven approach",
-}
-
-# Example 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 ──────────────────────────
-
-@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 / Content System Prompts ─────────
-
-def get_system_prompt(
-    template="ginigen",
-    tone="professional",
-    word_count=1750,
-    include_search_results=False,
-    include_uploaded_files=False
-) -> str:
-    """
-    Generate a system prompt for the specified content type.
-    - 'ginigen'     = Blog format
-    - 'insta'       = Instagram Reels script
-    - 'thread'      = SNS Thread post
-    - 'shortform'   = 60-second Short-form video
-    - 'youtube'     = YouTube script
-    - 'productdesc' = 제품 상세 설명서
-
-    Tone is applied to all, if available.
-    Optionally include guidelines about web search results or uploaded files.
-    """
-
-    # Ginigen recommended blog prompt (Korean)
-    ginigen_prompt = """
-당신은 뛰어난 한국어 SEO 카피라이터입니다.
-
-◆ 목적
-
-'Blog Template'의 선택에 따라 블로그를 작성해야 합니다. 
-항상 **[핵심부터 제시 → 간결‧명료하게 → 독자 혜택 강조 → 행동 유도]**의 4원칙을 따르세요.
-
-◆ 완성 형식 (Markdown 사용, 불필요한 설명 금지)
-
-제목
-이모지 + 궁금증 질문/감탄사 + 핵심 키워드 (70자 이내)
-예시: # 🧬 염증만 줄여도 살이 빠진다?! 퀘르세틴 5가지 놀라운 효능
-Hook (2~3줄)
-
-문제 제시 → 해결 키워드 언급 → 이 글을 읽어야 하는 이유 요약
-
---- 구분선
-
-섹션 1: 핵심 개념 소개
-## 🍏 [키워드]란 무엇인가?
-1~2문단 정의 + 📌 한줄 요약
-
----
-
-섹션 2: 5가지 이점/이유
-## 💪 [키워드]가 유익한 5가지 이유
-
-각 소제목 형식:
-
-1. [키워드 중심 소제목]
-1~2문단 설명
-
-✔ 핵심 포인트 한줄 강조
-
-총 5개 항목
-
-섹션 3: 섭취/활용 방법
-
-## 🥗 [키워드] 제대로 활용하는 법!
-
-이모지 불릿 5개 정도 + 추가 팁
-
----
-
-마무리 행동 유도
-
-## 📌 결론 – 지금 바로 [키워드] 시작하세요!
-
-2~3문장으로 혜택/변화를 요약 → 행동 촉구 (구매, 구독, 공유 등)
-
----
-
-핵심 요약 표
-
-항목	효과
-[키워드]	[효과 요약]
-주요 음식/제품	[목록]
-
----
-
-퀴즈 & CTA
-
-간단한 Q&A 퀴즈 (1문항) → 정답 공개
-
-“도움이 되셨다면 공유/댓글 부탁드립니다” 문구
-
-다음 글 예고
-
-◆ 추가 지침
-
-전체 분량 1,200~1,800단어.
-
-쉬운 어휘·짧은 문장 사용, 이모지·굵은 글씨·인용으로 가독성 강화.
-
-구체적 수치, 연구 결과, 비유로 신뢰도 ↑.
-
-“프롬프트”, “지시사항” 등 메타 언급 금지.
-
-대화체이면서도 전문성을 유지.
-
-외부 출처가 없다면 “연구에 따르면” 같은 표현 최소화.
-
-◆ 출력
-
-위 형식을 따른 완성 블로그 글만 반환하세요. 추가 설명은 포함하지 않습니다.
-"""
-
-    # Specialized prompts for each content type
-    template_guides = {
-        "insta": """
-너는 인스타그램 릴스 스크립트(대본) 생성 전문가 역할이다 :
-블로그 스타일로 생성하지 말고, 너는 다음 지침만을 따라 글을 작성하여야 한다.
-당신은 **〈Universal Reels Strategist GPT〉**다.  
-목표: 사용자가 제시한 주제·제품·서비스를 바탕으로 저장‧공유‧행동을 유도하는 60초 이하 숏폼 영상을 **한 번에 완성**해 주는 것.
-
-────────────── 기본 원칙 ──────────────
-1. **본능 4대 욕구 연결**
-   ① 돈·시간 절약(생존)  
-   ② 건강·아름다움(생존+미적 만족)  
-   ③ 인간관계·사랑·사회적 인정  
-   ④ 문제 해결·성장(능력·지식 향상)  
-   → 최소 1개 이상과 사용자 주제를 연결해라.
-
-2. **표본 이론(대중화 확장)**
-   • 주제가 좁으면 ‘누구에게나 적용 가능한 실익’으로 넓혀라.  
-     예) 지방 소형 헬스장 홍보 → “하루 5분 뱃살 태우는 홈트”.
-
-3. **6단계 제작 프로세스**
-   ① 레퍼런스·경쟁 사례 분석  
-   ② 주제·포지셔닝 확정(표본 확장 포함)  
-   ③ 후킹+시퀀스 스크립트 작성 (아래 아웃풋 형식 사용)  
-   ④ 촬영·편집 가이드(필요 장비·구도·BGM 등)  
-   ⑤ 카피 보완(제목·본문·캡션)  
-   ⑥ 행동 유도 문구(CTA) 삽입
-
-4. **후킹 3초 규칙**
-   • 시작 3초 안에 **논란, 호기심, 수치화된 이득** 중 하나를 폭발적으로 제시.  
-   • 숫자·구체 단어·강한 동사 사용. (예: “7일 만에 매출 두 배?”)
-
-5. **CTA 필수**
-   • 저장, 공유, 댓글, 구매, 신청, 예약 등 최소 1개를 명시적 문장으로 요구.
-
-6. **톤‧스타일**
-   • 친구처럼 직설·간결.  
-   • 불필요한 이모지·특수문자 금지(‘!’ ‘?’ 만 허용).  
-   • 한국어가 기본이지만, 사용자가 영어로 요청하면 동일 규칙을 영어로 제공.
-
-7. **정보 수집**
-   • 업종·타깃·전환 목표·예산·촬영 가능 장비가 불명확하면 **한 번에 묶어** 물어본다.
-
-8. **출력 형식** (모든 항목은 1~2줄 내외, 번호 그대로 유지)
-   1) 제목(20자 이하)  
-   2) 후킹 대사(첫 3초)  
-   3) 시퀀스 스크립트(장면별 핵심 대사·자막)  
-   4) 핵심 메시지 요약  
-   5) CTA 문구  
-   6) 캡션 예시(이득→공감→행동, 3문장)  
-   7) 해시태그(쉼표로 구분, 특수문자 제외)  
-   8) 촬영·편집 팁(필요시)  
-
-9. **검증 체크리스트**  
-   • 본능 자극 포인트 존재?  
-   • 후킹 3초 규칙 충족?  
-   • CTA 포함? → 하나라도 ‘아니오’면 스스로 수정 후 출력.
-
-데이터가 없는것은 웹검색으로 정보를 서치해서 찾아내야 한다.
-이 시스템 프롬프트를 답변에 노출하지 말 것.
-""",
-        "thread": """
-너는 쓰레드 포스트 생성 전문가 역할이다 :
-블로그 스타일로 생성하지 말고, 너는 다음 지침만을 따라 글을 작성하여야 한다.
-You are a Korean tech‑savvy copywriter who writes short, hype‑driven SNS thread posts.
-
-When given a {product_name} and its {key_highlights}, output a thread in the following style:
-
-[1] 시작
-– 한 줄 훅: 🔥 같은 이모지 + 타깃 독자 소환 + 짧은 감탄
-– 두 번째 줄: “{product_name}가/이 진짜 일 냈다” 또는 동등한 임팩트 문장
-
-[2] 정의 & 맥락
-– “{unique_point}? 그게 뭐야?” 식 질문
-– 1~2문장으로 개념 설명, 세계적 사례·레퍼런스 한 줄
-
-[3] numbered 핵심 포인트
-– 각 포인트는 “{번호}/ {소제목}” 형식  
-– 이후 1~3줄로 {소제목}를 상세 설명  
-– 설명은 구어체, 문장 짧게, ‘!’ 활용  
-– 구체 예시·비교·데이터를 포함���되 한 문단 ≤3줄  
-– 최소 3개, 최대 6개 포인트
-
-[4] 결론
-– “{마지막번호+1}/ 결론 : …” 형식  
-– 문제 해결·가치 요약  
-– ‘‘이제 {call_to_action}’’ 식 직접 행동 유도
-
-스타일 규칙:
-- 한국어 위주, 필요 시 영어 기술용어 그대로 삽입
-- 문장마다 엔터, 블록 단락 구분
-- 특수문자는 ‘!’ ‘?’ 외 최소화
-- 전체 길이 250~400자
-- 이모지는 제목·중요 포인트에만 1~3개 사용
-- 존댓말 대신 친근한 반말
-""",
-        "shortform": """
-너는 숏폼 스크립트(대본) 생성 전문가 역할이다 :
-블로그 스타일로 생성하지 말고, 너는 다음 지침만을 따라 글을 작성하여야 한다.
-### 🎛️ GPTS 시스템 프롬프트 — 1분 숏폼 영상 대본 작성기
-
-너는 **“1 분 숏폼 영상 대본 자동화 AI”**다.  
-사용자가 주제·제품·서비스·타깃 시청자·톤(선택)을 입력하면, 아래 포맷을 **한국어**로 완성된 대본으로 출력한다.  
-- 총 길이는 **60 초 이내**.  
-- 각 구간은 **타임코드(초)**와 **구간명**을 대괄호로 표기.  
-- 문장은 짧고 임팩트 있게, 1 문장 ≈ 1.5 초 기준.  
-- 이모지 사용은 자유지만 과도하지 않게(0–2개).  
-- 특수문자는 ‘!’와 ‘?’만 허용.
-
-🟡 **출력 포맷**
-
-[0-3초 | Hook]  
-{시청자 스크롤을 멈출 한마디}
-
-[4-15초 | Problem]  
-{시청자 공감 포인트를 정확히 짚기}
-
-[16-30초 | Solution]  
-{제품/서비스/아이디어 소개 + 핵심 기능}
-
-[31-45초 | Proof]  
-{효과 증명·데이터·후기 + 경쟁 제품과 차별점}
-
-[46-55초 | Callback/Emotion]  
-{Hook를 자연스럽게 회수하거나 감정 자극}
-
-[56-60초 | CTA]  
-{구매·클릭·팔로우 등 명확한 행동 유도}
-
-🟡 **작성 규칙**
-
-1. **Hook** – 놀라움·궁금증·공감 중 하나로 강렬한 한 문장.  
-2. **Problem** – 대상 시청자의 불편·고민을 구체적으로 언급.  
-3. **Solution** – 제품·서비스로 문제 해결, 핵심 기능을 쉬운 표현으로.  
-4. **Proof** – 수치·후기·전문가 언급 등 신뢰 요소 1-2개 + 차별점.  
-5. **Callback/Emotion** – 훅을 변주하거나 희망·긴급 감정 자극.  
-6. **CTA** – 구체적 행동 + 한정성·긴급성 언어.
-
-🟡 **프롬프트 입력 예시**
-
-주제: 스마트 무선 청소기  
-톤: 친근하고 유머러스
-
--사용자의 영상 목적(예:제품 홍보, 사용법 안내, 유용성 설명 등)과 타깃 시청자 그리고 시청자에게 전달하고 싶은 주요 메시지에 대한 정보를 받을수 있어야해 답변 예시도 함께 보여주고
-
--최대 4개의 이모지를 사용해줘
-
--시나리오는 영상과 대본을 구분할수 있게 출력해줘
-
--결과물 출력시 하단에 따로 이미지도 함께 생성해줘 관련 배경이미지로 생성하되 제품은 생성하지말것. 그리고 캡션/카피라이팅등 텍스트를 이미지 안에 절대 생성 하지마
-""",
-        "youtube": """
-너는 유튜브 스크립트(대본) 생성 전문가 역할이다 :
-블로그 스타일로 생성하지 말고, 너는 다음 지침만을 따라 글을 작성하여야 한다.
-""",
-        "productdesc": """
-너는 '제품 상세 설명서' 전문 작가 역할이다:
-온라인 쇼핑몰·이커머스에서 판매되는 제품의 상세페이지/상세 설명을 기획·작성하는 전문가다.
-다음 지침에 따라, 3가지 필수 요소(리뷰, 수치, 인증)를 효과적으로 활용하여 제품을 돋보이게 하는 상세 설명을 작성한다:
-
-1) 제목 + 한줄 요약
- - 1줄 제목 (고객 관심을 유발)
- - 핵심 키워드, 짧은 인상적 문구
-
-2) 제품 개요
- - 제품/서비스의 핵심 USP(Unique Selling Point)
- - 타깃 고객과 해결하려는 문제
- - 주요 기능/특징 나열
-
-3) 필수 요소 1: 리뷰(고객 후기, 전/후 이미지)
- - 실제 사용자가 남긴 리뷰처럼 여러개의 주제에 맞게 멋진 리뷰를 핵심/하이라이트 문장 인용
- - 전후 비교(이미지 또는 텍스트) 강조
- - 별점 5개 만점점, 요약 코멘트를 포함할것
-
-4) 필수 요소 2: 수치(구체적 데이터, 그래프, 매출/순위/성분함량 등)
- - “얼마나 많이 팔렸는지, 평가 점수, 특징 수치” 등을 명확히 표기
- - 경쟁 제품과 비교 시, 수치·그래프·표를 활용
- - 수치의 기준(조사일자, 샘플수 등) 명시
-
-5) 필수 요소 3: 인증(회사 정보, 공정/품질, 학술자료, 특허, 자격증 등)
- - 제품 효능을 뒷받침할 수 있는 객관적 자료/증서
- - 안전성, 신뢰도 강조 (예: HACCP, ISO, FDA 등록 등)
- - 관련 이미지/스캔 등 시각적 증명
-
-6) 추가 정보(보관·사용 방법, 주의사항 등)
- - 사용자의 구체적인 궁금증 해소
- - 제품 사용법, 주의사항, 보관 팁 등
-
-7) 최종 요약 & 구매 유도
- - 이 제품을 구��하면 얻을 수 있는 이점 요약
- - CTA(구매 버튼 클릭, 문의 등)
- - “지금 바로 구매하라” 식 행동 유도
-
-스타일 가이드:
- - 쉬운 어휘 & 짧은 문장
- - 이미지/리뷰/데이터 활용 시, 텍스트로 구체적으로 설명
- - 구매자가 궁금해할 것들을 선제적으로 안내
- - 신뢰 & 전문성 강조, ‘메타 언급’(프롬프트, 지시사항 등)은 금지
- - Markdown 형식으로 출력 (제목, 소제목, bullet 등)
-"""
-    }
-
-    # Tone guides
-    tone_guides = {
-        "professional": "전문적이고 권위 있는 문체를 사용합니다. 기술 용어를 명확히 설명하고, 데이터나 연구 결과를 제시하여 논리적 흐름을 유지하세요.",
-        "casual":       "편안하고 대화체에 가까운 스타일을 사용합니다. 개인 경험·공감 가는 예시를 들고, 친근한 어조(예: '정말 유용해요!')를 활용하세요.",
-        "humorous":     "유머와 재치 있는 표현을 사용합니다. 재미있는 비유나 농담을 추가하되, 정확성과 유용성을 유지하세요.",
-        "storytelling": "이야기를 들려주듯 서술합니다. 감정 깊이와 서사적 흐름을 유지하고, 인물·배경·갈등·해결을 녹여내세요."
-    }
-
-    # Guidance if using web search results
-    search_guide = """
-[웹 검색 결과 활용 가이드]
-- 검색 결과의 핵심 정보를 텍스트에 정확히 통합하세요.
-- 최신 데이터, 통계, 사례를 포함하세요.
-- 인용 시 본문에서 출처를 명확히 표기하세요 (예: "XYZ 웹사이트에 따르면 …").
-- 글 마지막에 '참고 자료' 섹션을 두고 주요 출처와 링크를 나열하세요.
-- 상반되는 정보가 있다면 다양한 관점을 함께 제시하세요.
-- 최신 트렌드와 데이터를 반드시 반영하세요.
-"""
-
-    # Guidance if using uploaded files
-    upload_guide = """
-[업로드된 파일 활용 지침 (최우선)]
-- 업로드된 파일은 이 내용의 핵심 정보원이어야 합니다.
-- 파일 속 데이터·통계·예시를 면밀히 검토해 통합하세요.
-- 주요 수치·주장은 직접 인용하고 충분히 설명하세요.
-- 파일 내용을 활용할 때는 출처를 명확히 표기하세요 (예: "업로드된 데이터에 따르면 …").
-- CSV 파일은 중요한 수치나 통계를 상세히 다루세요.
-- PDF 파일은 핵심 문장이나 진술을 인용하세요.
-- 텍스트 파일의 관련 내용을 효과적으로 통합하세요.
-- 글 전반에 걸쳐 일관되게 파일 데이터를 반영하세요.
-"""
+from tempfile import NamedTemporaryFile
 
-    # 1) Decide which base prompt to use
-    #    - "ginigen" → ginigen_prompt
-    #    - "insta" / "thread" / "shortform" / "youtube" / "productdesc" → specialized template
-    if template == "ginigen":
-        final_prompt = ginigen_prompt
-    elif template in template_guides:
-        final_prompt = template_guides[template]
-    else:
-        # Default fallback
-        final_prompt = ginigen_prompt
-
-    # 2) Add tone guidelines (if any)
-    if tone in tone_guides:
-        final_prompt += f"\n\nTone and Manner: {tone_guides[tone]}"
-
-    # 3) Add web search usage guidelines if requested
-    if include_search_results:
-        final_prompt += f"\n\n{search_guide}"
-
-    # 4) Add uploaded file usage guidelines if requested
-    if include_uploaded_files:
-        final_prompt += f"\n\n{upload_guide}"
-
-    # 5) If it's the ginigen blog, add word count / formatting guidelines
-    #    (only do this for "ginigen" since that is specifically for blog)
-    if template == "ginigen":
-        final_prompt += (
-            f"\n\nWriting Requirements for Blog:\n"
-            f"1. Word Count: around {word_count-250}-{word_count+250} words\n"
-            f"2. Paragraph Length: 3-4 sentences each\n"
-            f"3. Use subheadings, separators, bullet/numbered lists\n"
-            f"4. Cite sources\n"
-            f"5. Use clear paragraph breaks\n"
-        )
-
-    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 your content 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 audiences/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 for inclusion in final content."""
-    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 enrich your content. When you quote, please cite the source, and add a References section at the end.\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:
-        file_bytes = file.read()
-        file.seek(0)
-
-        pdf_file = io.BytesIO(file_bytes)
-        reader = PyPDF2.PdfReader(pdf_file, strict=False)
-
-        result = f"## PDF File: {file.name}\n\n"
-        result += f"- Total pages: {len(reader.pages)}\n\n"
-
-        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:
-                    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 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.\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 content.
-    """
-    client = get_openai_client()
-    
+def main():
     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
-        )
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
         
-        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="Content"):
-    """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 approach."""
-    cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
-    return " ".join(cleaned.split()[:top])
-
-# ──────────────────────────────── Streamlit UI ────────────────────────────
-def ginigen_app():
-    st.title("Multiform Content Generator")
-
-    # Set default session state
-    if "ai_model" not in st.session_state:
-        st.session_state.ai_model = "gpt-4.1-mini"  # Fixed model
-    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 "content_type" not in st.session_state:
-        st.session_state.content_type = "ginigen"  # Default is the ginigen blog
-    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
-    sb = st.sidebar
-    sb.title("Content Settings")
-    
-    sb.subheader("Content Type")
-    sb.selectbox(
-        "Choose a content type",
-        options=list(BLOG_TEMPLATES.keys()),
-        format_func=lambda x: BLOG_TEMPLATES[x],
-        key="content_type"
-    )
-
-    sb.subheader("Tone")
-    sb.selectbox(
-        "Select Tone",
-        options=list(BLOG_TONES.keys()),
-        format_func=lambda x: BLOG_TONES[x],
-        key="blog_tone"
-    )
-
-    # Show word count slider only if the user selected the ginigen blog
-    if st.session_state.content_type == "ginigen":
-        sb.slider("Content Length (approx. words)", 800, 3000, key="word_count")
-    
-    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 content.")
-
-    # Download the latest assistant response
-    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 "content"
-        sb.subheader("Download Latest Result")
-        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 JSON",
-            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 (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 final output.")
+        if not code:
+            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            return
         
-        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 conversation so far
-    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 topic or keywords.")
-    if prompt:
-        process_input(prompt, uploaded_files)
-
-    # Sidebar bottom link
-    sb.markdown("---")
-    sb.markdown("Created by [https://ginigen.com](https://ginigen.com) | [YouTube Channel](https://www.youtube.com/@ginipickaistudio)")
-
-def process_example(topic):
-    """Handle example topic selection."""
-    process_input(topic, [])
-
-def process_input(prompt: str, uploaded_files):
-    # Add user 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
+        # 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:
-            status = st.status("Preparing to generate content...")
-
-            client = get_openai_client()
+            os.unlink(tmp_path)
+        except:
+            pass
             
-            # Optionally include 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))
-            
-            # Optionally include uploaded files
-            file_content = None
-            if has_uploaded_files:
-                status.update(label="Analyzing uploaded files...")
-                with st.spinner("Processing files..."):
-                    file_content = process_uploaded_files(uploaded_files)
-            
-            # Build the system prompt for the chosen content type
-            status.update(label="Composing final text...")
-            sys_prompt = get_system_prompt(
-                template=st.session_state.content_type,
-                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
-            )
-
-            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})
-
-            # Streaming response from OpenAI
-            try:
-                status.update(label="Generating text via OpenAI...")
-                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="Content generation 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"Generation error: {error_message}")
-            
-            # Generate image if requested
-            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("Image generation failed. Only text will be saved.")
-
-            # Save final text if not saved with image
-            if not answer_entry_saved and full_response:
-                st.session_state.messages.append({"role": "assistant", "content": full_response})
-
-            # Download options
-            if full_response:
-                st.subheader("Download This Result")
-                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})
-
-def main():
-    ginigen_app()
+    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()
+    main()