Update app.py

app.py

@@ -2098,200 +2098,268 @@ def translate_to_korean(text, category=None):
     return translations.get(text, text)
 
 def generate_random_theme(language="English"):
-    """Generate an interesting random novel theme with smart compatibility"""
+    """Generate a coherent and natural novel theme using LLM"""
     try:
-        # JSON 파일 경로 확인
+        # JSON 파일 로드
         json_path = Path("novel_themes.json")
-        
-        # JSON 파일이 없으면 내장 데이터 사용
         if not json_path.exists():
             print("[WARNING] novel_themes.json not found, using built-in data")
-            # 여기에 직접 테마 데이터 정의
-            themes = [
-                "digital_extinction", "sensory_revolution", "temporal_paradox", 
-                "emotional_economy", "linguistic_apocalypse", "algorithmic_mysticism",
-                "biological_nostalgia", "social_physics", "reality_bureaucracy",
-                "dream_industrialization", "genetic_copyright", "atmospheric_capitalism"
-            ]
-            
-            characters = [
-                "last person who dreams without ads",
-                "excavator of deleted conversations", 
-                "black market memory dealer",
-                "guerrilla flavor bomber",
-                "temporal audit specialist",
-                "organic emotion cultivator",
-                "binary meditation teacher",
-                "extinct plant memory keeper",
-                "social distance calibrator",
-                "subconscious strip miner"
-            ]
-            
-            hooks = [
-                "discovers their memories belong to a corporate subscription service",
-                "realizes they're the only person not running on autopilot",
-                "finds out their personality is a discontinued model",
-                "learns their emotions are being crowdsourced",
-                "discovers they're allergic to their own digital footprint",
-                "causes the first spontaneous laughter in a decade",
-                "accidentally introduces randomness into a perfect system",
-                "finds the last handwritten letter in existence"
-            ]
-            
-            openings = [
-                "The notification read: 'Your humanity subscription expires in 24 hours.'",
-                "I was the only one at the funeral who couldn't stream my grief.",
-                "The day empathy became downloadable was the day I became obsolete.",
-                "My daughter asked me what dreams were, and I realized I'd forgotten.",
-                "The silence lasted twelve seconds—a new world record.",
-                "The happiness mandate made funerals unbearably cheerful.",
-                "My genetic audit revealed I was 3% copyrighted material.",
-                "They repossessed my childhood memories this morning."
-            ]
-            
-            questions = [
-                "What remains human when humanity is optional?",
-                "Is consciousness a bug or a feature?",
-                "Can nostalgia exist without mortality?",
-                "Who owns the right to forget?",
-                "Is numbness a form of control?",
-                "What happens when words lose meaning?",
-                "Do algorithms dream of digital souls?",
-                "Are we variables in God's code?"
-            ]
-            
+            # 기본 데이터 정의
+            themes_data = {
+                "themes": ["digital extinction", "sensory revolution", "temporal paradox"],
+                "characters": ["memory trader", "time thief", "emotion farmer"],
+                "hooks": ["discovering hidden truth", "facing impossible choice", "breaking the system"],
+                "questions": ["What makes us human?", "Can memory define identity?", "Is free will an illusion?"]
+            }
         else:
-            # JSON 파일 로드
             with open(json_path, 'r', encoding='utf-8') as f:
                 data = json.load(f)
+                themes_data = {
+                    "themes": list(data.get('core_themes', {}).keys()),
+                    "characters": [],
+                    "hooks": [],
+                    "questions": []
+                }
                 
-            themes = list(data['core_themes'].keys())
-            characters = []
-            for char_data in data['characters'].values():
-                characters.extend(char_data.get('variations', []))
-            
-            hooks = []
-            for hook_list in data['narrative_hooks'].values():
-                hooks.extend(hook_list)
-                
-            openings = []
-            for opening_list in data['opening_sentences'].values():
-                openings.extend(opening_list)
-                
-            questions = []
-            for phil_data in data['philosophies'].values():
-                questions.extend(phil_data.get('core_questions', []))
-        
-        # 진짜 랜덤 선택을 위해 인덱스 기반 선택
-        import os
-        
-        # OS의 진짜 랜덤 사용
-        theme = themes[int.from_bytes(os.urandom(1), 'big') % len(themes)]
-        character = characters[int.from_bytes(os.urandom(1), 'big') % len(characters)]
-        hook = hooks[int.from_bytes(os.urandom(1), 'big') % len(hooks)]
-        opening = openings[int.from_bytes(os.urandom(1), 'big') % len(openings)]
-        question = questions[int.from_bytes(os.urandom(1), 'big') % len(questions)]
-        
-        # 랜덤 메시지
-        messages = [
-            'resistance is creation',
-            'memory is rebellion', 
-            'imperfection is sacred',
-            'connection transcends system',
-            'humanity is a choice not a default'
-        ]
-        message = messages[int.from_bytes(os.urandom(1), 'big') % len(messages)]
-        
-        # 한국어 번역
+                # Extract data from JSON
+                for char_data in data.get('characters', {}).values():
+                    themes_data["characters"].extend(char_data.get('variations', []))
+                for hook_list in data.get('narrative_hooks', {}).values():
+                    themes_data["hooks"].extend(hook_list)
+                for phil_data in data.get('philosophies', {}).values():
+                    themes_data["questions"].extend(phil_data.get('core_questions', []))
+        
+        # Random selection with better randomization
+        import secrets
+        theme = secrets.choice(themes_data["themes"])
+        character = secrets.choice(themes_data["characters"])
+        hook = secrets.choice(themes_data["hooks"])
+        question = secrets.choice(themes_data["questions"])
+        
+        # Create a natural prompt for LLM to generate coherent theme
         if language == "Korean":
-            # 번역 로직
-            character = translate_to_korean(character)
-            question = translate_to_korean(question)
-            hook = translate_to_korean(hook)
-            opening = translate_to_korean(opening)
-            theme_kr = translate_to_korean(theme)
-            
-            message_kr = {
-                'resistance is creation': '저항이 곧 창조인지',
-                'memory is rebellion': '기억이 곧 반란인지', 
-                'imperfection is sacred': '불완전함이 신성한지',
-                'connection transcends system': '연결이 시스템을 초월하는지',
-                'humanity is a choice not a default': '인간성은 기본값이 아닌 선택인지'
-            }
-            message = message_kr.get(message, message)
-            
-            return f"""**제목 컨셉:** '{character.split()[0]}의 {theme_kr}'
+            prompt = f"""다음 요소들을 사용하여 자연스럽고 흥미로운 소설 주제를 생성하세요:
+
+주제: {theme}
+캐릭터: {character}
+사건: {hook}
+철학적 질문: {question}
+
+요구사항:
+1. 모든 요소가 유기적으로 연결된 하나의 통합된 주제
+2. 구체적이고 독창적인 설정
+3. 명확한 갈등과 긴장감
+4. 현대적 관련성
+5. 문학적 깊이
+
+다음 형식으로 작성하세요:
+- 제목: [매력적이고 암시적인 제목]
+- 첫 문장: [독자를 즉시 사로잡는 강렬한 첫 문장]
+- 주인공: [구체적인 상황과 특성을 가진 인물]
+- 중심 갈등: [내적 갈등과 외적 갈등의 결합]
+- 탐구 주제: [철학적 깊이를 가진 핵심 질문]"""
+        else:
+            prompt = f"""Generate a natural and compelling novel theme using these elements:
+
+Theme: {theme}
+Character: {character}
+Event: {hook}
+Philosophical Question: {question}
+
+Requirements:
+1. All elements organically connected into one unified theme
+2. Specific and original setting
+3. Clear conflict and tension
+4. Contemporary relevance
+5. Literary depth
+
+Format as:
+- Title: [Compelling and evocative title]
+- Opening: [Powerful first sentence that immediately hooks readers]
+- Protagonist: [Character with specific situation and traits]
+- Central Conflict: [Combination of internal and external conflict]
+- Core Exploration: [Philosophically deep central question]"""
+
+        # Use the UnifiedLiterarySystem's LLM to generate coherent theme
+        system = UnifiedLiterarySystem()
+        
+        # Call LLM synchronously for theme generation
+        messages = [{"role": "user", "content": prompt}]
+        generated_theme = system.call_llm_sync(messages, "director", language)
+        
+        # Add narrative structure (simplified and natural)
+        if language == "Korean":
+            generated_theme += f"""
 
-**첫 문장:** "{opening}"
+**서사 구조:**
+이 이야기는 {character}가 {hook.lower()}는 충격적 사건으로 시작됩니다.
+점차 심화되는 갈등을 통해 {question.lower().rstrip('?')}라는 근본적 질문과 대면하게 되며,
+궁극적으로 {theme.replace('_', ' ')}의 시대를 살아가는 현대인의 실존적 선택을 그립니다.
 
-**중심 인물:** {hook}하는 {character}.
+**톤과 스타일:**
+현대 문학의 ���리적 깊이와 철학적 통찰을 결합하여, 독자로 하여금 
+자신의 삶을 돌아보게 만드는 성찰적 서사를 지향합니다."""
+        else:
+            generated_theme += f"""
 
-**핵심 철학적 질문:** {question}
+**Narrative Arc:**
+The story begins with {character} who {hook}, a shocking event that sets everything in motion.
+Through deepening conflicts, they confront the fundamental question of {question.lower()}
+ultimately portraying the existential choices of modern humans living in an era of {theme.replace('_', ' ')}.
 
-**서사 구조:**
-- 파트 1-2: 균열된 현실의 발견
-- 파트 3-4: 중심 갈등의 심화
-- 파트 5-6: 숨겨진 진실의 발견
-- 파트 7-8: 궁극적 선택의 직면
-- 파트 9-10: 자아와 세계의 변화
+**Tone and Style:**
+Combining the psychological depth and philosophical insights of contemporary literature,
+aiming for a reflective narrative that makes readers examine their own lives."""
+        
+        return generated_theme
+        
+    except Exception as e:
+        logger.error(f"Theme generation error: {str(e)}")
+        # Fallback to simple pre-defined themes
+        fallback_themes = {
+            "Korean": [
+                """**제목:** 마지막 아날로그 인간
 
-**주제적 핵심:** 이 이야기는 {theme_kr}가 근본적으로 인간 존재를 변화시킨 세계에서 {character}의 여정을 통해 {question.lower().rstrip('?')}를 탐구합니다.
+**첫 문장:** "내가 마지막으로 종이에 글을 쓴 사람이 된 날, 세상은 침묵했다."
 
-**톤:** 어둡지만 유머러스하고 심오한 - 카프카, 보르헤스, 한강이 그들의 가장 어두운 비전을 넘어선 세계를 위해 글을 쓴다고 상상해보세요.
+**주인공:** 디지털화를 거부하고 수기로만 소통하는 노년의 작가
 
-**메시지:** {theme_kr}를 탐구하면서, 이 이야기는 {message} 묻습니다."""
-            
-        else:
-            return f"""**Title Concept:** 'The {character.split()[0].title()}'s {theme.replace('_', ' ').title()}'
+**중심 갈등:** 효율성과 인간성 사이에서 선택해야 하는 실존적 딜레마
+
+**탐구 주제:** 기술 발전 속에서 인간 고유의 가치는 무엇인가?""",
+                
+                """**제목:** 기억 거래소
 
-**Opening Sentence:** "{opening}"
+**첫 문장:** "오늘 아침, 나는 첫사랑의 기억을 팔기로 결정했다."
 
-**Central Character:** A {character} who {hook}.
+**주인공:** 생계를 위해 소중한 기억을 파는 젊은 예술가
 
-**Core Philosophical Question:** {question}
+**중심 갈등:** 생존과 정체성 보존 사이의 선택
 
-**Narrative Arc:**
-- Parts 1-2: Discovery of fractured reality
-- Parts 3-4: Deepening central conflict
-- Parts 5-6: Uncovering hidden truths
-- Parts 7-8: Confronting ultimate choice
-- Parts 9-10: Transformation of self and world
+**탐구 주제:** 기억이 거래되는 시대, 우리는 무엇으로 자신을 정의하는가?"""
+            ],
+            "English": [
+                """**Title:** The Last Analog Human
 
-**Thematic Core:** This story explores {question.lower()} through the journey of {character} in a world where {theme.replace('_', ' ')} has fundamentally altered human existence.
+**Opening:** "The day I became the last person to write on paper, the world fell silent."
+
+**Protagonist:** An elderly writer who refuses digitalization and communicates only through handwriting
+
+**Central Conflict:** Existential dilemma between efficiency and humanity
+
+**Core Exploration:** What is uniquely human in the age of technological advancement?""",
+                
+                """**Title:** The Memory Exchange
 
-**Tone:** Darkly humorous yet profound - imagine Kafka, Borges, or Atwood writing for a world that has surpassed their darkest visions.
+**Opening:** "This morning, I decided to sell my first love's memory."
 
-**Message:** In exploring {theme.replace('_', ' ')}, the story asks whether {message}."""
+**Protagonist:** A young artist selling precious memories for survival
+
+**Central Conflict:** Choice between survival and preserving identity
+
+**Core Exploration:** In an era where memories are traded, what defines who we are?"""
+            ]
+        }
         
+        import secrets
+        return secrets.choice(fallback_themes.get(language, fallback_themes["English"]))
+
+# Update the handle_random_theme function in create_interface
+def handle_random_theme(language):
+    """Handle random theme generation with improved feedback"""
+    try:
+        # Generate theme using LLM for natural output
+        theme = generate_random_theme(language)
+        logger.info(f"Generated theme successfully")
+        return theme
     except Exception as e:
-        print(f"[CRITICAL ERROR] {str(e)}")
-        # 진짜 간단한 랜덤 생성
-        import hashlib
-        import datetime
-        
-        # 현재 시간의 해시값으로 인덱스 생성
-        time_hash = hashlib.md5(str(datetime.datetime.now()).encode()).hexdigest()
-        idx = int(time_hash[:8], 16)
-        
-        simple_themes = [
-            ("기억 거래상", "Memory Trader"),
-            ("시간 도둑", "Time Thief"),
-            ("감정 농부", "Emotion Farmer"),
-            ("꿈 광부", "Dream Miner"),
-            ("침묵 수집가", "Silence Collector")
-        ]
+        logger.error(f"Random theme generation failed: {str(e)}")
+        # Return a simple fallback theme
+        if language == "Korean":
+            return "기억을 잃어가는 노인과 AI 간병인의 특별한 우정"
+        else:
+            return "An unlikely friendship between an elderly person losing memories and their AI caregiver"
+
+# Update the augment_query method to better handle generated themes
+def augment_query(self, user_query: str, language: str) -> str:
+    """Augment and clean user query"""
+    # Remove any formatting artifacts from random generation
+    if "**" in user_query or "##" in user_query:
+        # This is likely a generated theme with formatting
+        # Extract the essence without formatting
+        lines = user_query.split('\n')
+        cleaned_parts = []
         
-        theme = simple_themes[idx % len(simple_themes)]
+        for line in lines:
+            # Remove markdown formatting
+            line = line.replace('**', '').replace('##', '').strip()
+            if line and not line.startswith(('-', '•', '*')) and ':' not in line[:20]:
+                cleaned_parts.append(line)
         
+        if cleaned_parts:
+            user_query = ' '.join(cleaned_parts[:3])  # Use first few meaningful lines
+    
+    # If query is too short, enhance it
+    if len(user_query.split()) < 15:
         if language == "Korean":
-            return f"""**제목:** '{theme[0]}의 고백'
-**첫 문장:** "오늘도 나는 남들이 버린 것을 주웠다."
-**중심 갈등:** 인간의 본질적 가치가 거래되는 세계에서의 생존"""
+            return f"{user_query}\n\n이 주제를 현대적 관점에서 재해석하여 인간 존재의 본질과 기술 시대의 딜레마를 탐구하는 8,000단어 분량의 철학적 중편소설을 작성하세요."
         else:
-            return f"""**Title:** 'Confessions of a {theme[1]}'
-**Opening:** "Today again, I collected what others discarded."
-**Central Conflict:** Survival in a world where human essence is traded"""
-
+            return f"{user_query}\n\nReinterpret this theme from a contemporary perspective to explore the essence of human existence and dilemmas of the technological age in an 8,000-word philosophical novella."
+    
+    return user_query
+
+# Add method to UnifiedLiterarySystem class for better theme processing
+def process_generated_theme(self, theme_text: str, language: str) -> str:
+    """Process generated theme for novel writing"""
+    # Extract key elements from generated theme
+    theme_elements = {
+        "title": "",
+        "opening": "",
+        "protagonist": "",
+        "conflict": "",
+        "exploration": ""
+    }
+    
+    lines = theme_text.split('\n')
+    current_key = None
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # Detect sections
+        if any(marker in line.lower() for marker in ['title:', 'opening:', 'protagonist:', 'conflict:', 'exploration:', '제목:', '첫 문장:', '주인공:', '갈등:', '탐구']):
+            for key in theme_elements:
+                if key in line.lower() or (language == "Korean" and key in translate_to_korean(line.lower())):
+                    current_key = key
+                    # Extract content after colon
+                    if ':' in line:
+                        content = line.split(':', 1)[1].strip()
+                        if content:
+                            theme_elements[current_key] = content
+                    break
+        elif current_key and line:
+            # Continue adding to current element
+            theme_elements[current_key] = (theme_elements[current_key] + " " + line).strip()
+    
+    # Construct a coherent theme summary
+    if language == "Korean":
+        summary = f"{theme_elements.get('title', '무제')}. "
+        if theme_elements.get('opening'):
+            summary += f"'{theme_elements['opening']}' "
+        summary += f"{theme_elements.get('protagonist', '주인공')}의 이야기. "
+        summary += f"{theme_elements.get('conflict', '')} "
+        summary += f"{theme_elements.get('exploration', '')}"
+    else:
+        summary = f"{theme_elements.get('title', 'Untitled')}. "
+        if theme_elements.get('opening'):
+            summary += f"'{theme_elements['opening']}' "
+        summary += f"The story of {theme_elements.get('protagonist', 'a protagonist')}. "
+        summary += f"{theme_elements.get('conflict', '')} "
+        summary += f"{theme_elements.get('exploration', '')}"
+    
+    return summary.strip()
             
 # Create Gradio interface
 def create_interface():