Update app.py

app.py

@@ -2836,1116 +2836,6 @@ The more specific your concept, the better the screenplay will be tailored to yo
    
    return interface
 
-# Main function
-if __name__ == "__main__":
-   logger.info("Screenplay Generator Starting...")
-   logger.info("=" * 60)
-   
-   # Environment check
-   logger.info(f"API Endpoint: {API_URL}")
-   logger.info("Screenplay Types Available:")
-   for s_type, info in SCREENPLAY_LENGTHS.items():
-       logger.info(f"  - {s_type}: {info['description']}")
-   logger.info(f"Genres: {', '.join(GENRE_TEMPLATES.keys())}")
-   
-   if BRAVE_SEARCH_API_KEY:
-       logger.info("Web search enabled for market research.")
-   else:
-       logger.warning("Web search disabled.")
-   
-   logger.info("=" * 60)
-   
-   # Initialize database
-   logger.info("Initializing database...")
-   ScreenplayDatabase.init_db()
-   logger.info("Database initialization complete.")
-   
-   # Create and launch interface
-   interface = create_interface()
-   
-   interface.launch(
-       server_name="0.0.0.0",
-       server_port=7860,
-       share=False,
-       debug=True
-   ), '', value)
-            return value.strip() if value else None
-        return None
-
-import re
-from typing import List
-
-    def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-        """Parse character profile from content and return a CharacterProfile object."""
-        # --- 1. 로그 ---
-        logger.debug(f"Parsing character profile for role: {role}")
-        logger.debug(f"Content preview: {content[:200]}...")
-
-        # --- 2. 이름 추출 ---
-        name = f"Character_{role}"  # fallback
-        name_patterns = [
-            r'(?:이름|Name)[:\s]*([^\n,(]+)',     # 예: "이름: 홍길동"
-            r'^\s*[-*•]\s*([^\n,(]+)',            # 예: "- 홍길동"
-            r'^([^\n,(]+)'                        # 문단 첫 단어
-        ]
-        for pat in name_patterns:
-            m = re.search(pat, content, re.IGNORECASE | re.MULTILINE)
-            if m and m.group(1).strip():
-                extracted = m.group(1).strip()
-                # 마크다운·특수 기호 제거
-                extracted = re.sub(r'[\*:\s]+', '', extracted)
-                if len(extracted) > 1:
-                    name = extracted
-                    break
-
-        # --- 3. 필드 추출 헬퍼 ---
-        def extract_clean_field(patterns) -> str:
-            patterns = [patterns] if isinstance(patterns, str) else patterns
-            for p in patterns:
-                m = re.search(rf'{p}[:\s]*([^\n*]+?)(?=\n|$)', content,
-                              re.IGNORECASE | re.DOTALL)
-                if m and m.group(1).strip():
-                    val = m.group(1).strip()
-                    val = re.sub(r'^[-*•:\s]+', '', val)
-                    val = re.sub(r'\*+', '', val)
-                    val = re.sub(r'\s+', ' ', val)
-                    return val
-            return ""
-
-        # --- 4. Personality(여러 줄) 추출은 별도 메서드 사용 ---
-        profile = CharacterProfile(
-            name=name,
-            role=role,
-            archetype=extract_clean_field([
-                r"캐릭터 아크타입",
-                r"Character Archetype",
-                r"Archetype",
-                r"아크타입"
-            ]),
-            want=extract_clean_field([
-                r"WANT\s*\(외적 목표\)",
-                r"WANT",
-                r"외적 목표",
-                r"External Goal"
-            ]),
-            need=extract_clean_field([
-                r"NEED\s*\(내적 필요\)",
-                r"NEED",
-                r"내적 필요",
-                r"Internal Need"
-            ]),
-            backstory=extract_clean_field([
-                r"백스토리",
-                r"Backstory",
-                r"핵심 상처",
-                r"Core Wound"
-            ]),
-            personality=self._extract_personality_traits(content),
-            speech_pattern=extract_clean_field([
-                r"말투.*?패턴",
-                r"Speech Pattern",
-                r"언어 패턴",
-                r"말투"
-            ]),
-            character_arc=extract_clean_field([
-                r"캐릭터 아크",
-                r"Character Arc",
-                r"Arc",
-                r"변화"
-            ])
-        )
-
-        logger.debug(f"Parsed character: {profile.name}")
-        return profile
-
-    def _extract_personality_traits(self, content: str) -> List[str]:
-        """Extract personality traits from content."""
-        traits: List[str] = []
-        personality_patterns = [
-            r"(?:Personality|성격 특성|성격)[:\s]*([^\n]+(?:\n(?![\w가-힣]+:)[^\n]+)*)",
-            r"성격[:\s]*(?:\n?[-•*]\s*[^\n]+)+"
-        ]
-
-        for pattern in personality_patterns:
-            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-            if match and match.group(1):
-                section = match.group(1)
-                for line in section.split('\n'):
-                    line = line.strip()
-                    if line and not line.endswith(':'):
-                        trait = re.sub(r'^\s*[-•*]\s*', '', line)   # 글머리표 제거
-                        trait = re.sub(r'^\d+\.\s*', '', trait)     # 번호 제거
-                        if len(trait) > 2:
-                            traits.append(trait)
-                if traits:
-                    break
-
-        return traits[:5]  # 최대 5개
-        
-import re
-from typing import List
-
-    def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-        """Parse character profile from content and return a CharacterProfile object."""
-        # --- 1. 로그 ---
-        logger.debug(f"Parsing character profile for role: {role}")
-        logger.debug(f"Content preview: {content[:200]}...")
-
-        # --- 2. 이름 추출 ---
-        name = f"Character_{role}"  # fallback
-        name_patterns = [
-            r'(?:이름|Name)[:\s]*([^\n,(]+)',     # 예: "이름: 홍길동"
-            r'^\s*[-*•]\s*([^\n,(]+)',            # 예: "- 홍길동"
-            r'^([^\n,(]+)'                        # 문단 첫 단어
-        ]
-        for pat in name_patterns:
-            m = re.search(pat, content, re.IGNORECASE | re.MULTILINE)
-            if m and m.group(1).strip():
-                extracted = m.group(1).strip()
-                # 마크다운·특수 기호 제거
-                extracted = re.sub(r'[\*:\s]+', '', extracted)
-                if len(extracted) > 1:
-                    name = extracted
-                    break
-
-        # --- 3. 필드 추출 헬퍼 ---
-        def extract_clean_field(patterns) -> str:
-            patterns = [patterns] if isinstance(patterns, str) else patterns
-            for p in patterns:
-                m = re.search(rf'{p}[:\s]*([^\n*]+?)(?=\n|$)', content,
-                              re.IGNORECASE | re.DOTALL)
-                if m and m.group(1).strip():
-                    val = m.group(1).strip()
-                    val = re.sub(r'^[-*•:\s]+', '', val)
-                    val = re.sub(r'\*+', '', val)
-                    val = re.sub(r'\s+', ' ', val)
-                    return val
-            return ""
-
-        # --- 4. Personality(여러 줄) 추출은 별도 메서드 사용 ---
-        profile = CharacterProfile(
-            name=name,
-            role=role,
-            archetype=extract_clean_field([
-                r"캐릭터 아크타입",
-                r"Character Archetype",
-                r"Archetype",
-                r"아크타입"
-            ]),
-            want=extract_clean_field([
-                r"WANT\s*\(외적 목표\)",
-                r"WANT",
-                r"외적 목표",
-                r"External Goal"
-            ]),
-            need=extract_clean_field([
-                r"NEED\s*\(내적 필요\)",
-                r"NEED",
-                r"내적 필요",
-                r"Internal Need"
-            ]),
-            backstory=extract_clean_field([
-                r"백스토리",
-                r"Backstory",
-                r"핵심 상처",
-                r"Core Wound"
-            ]),
-            personality=self._extract_personality_traits(content),
-            speech_pattern=extract_clean_field([
-                r"말투.*?패턴",
-                r"Speech Pattern",
-                r"언어 패턴",
-                r"말투"
-            ]),
-            character_arc=extract_clean_field([
-                r"캐릭터 아크",
-                r"Character Arc",
-                r"Arc",
-                r"변화"
-            ])
-        )
-
-        logger.debug(f"Parsed character: {profile.name}")
-        return profile
-
-    def _extract_personality_traits(self, content: str) -> List[str]:
-        """Extract personality traits from content."""
-        traits: List[str] = []
-        personality_patterns = [
-            r"(?:Personality|성격 특성|성격)[:\s]*([^\n]+(?:\n(?![\w가-힣]+:)[^\n]+)*)",
-            r"성격[:\s]*(?:\n?[-•*]\s*[^\n]+)+"
-        ]
-
-        for pattern in personality_patterns:
-            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-            if match and match.group(1):
-                section = match.group(1)
-                for line in section.split('\n'):
-                    line = line.strip()
-                    if line and not line.endswith(':'):
-                        trait = re.sub(r'^\s*[-•*]\s*', '', line)   # 글머리표 제거
-                        trait = re.sub(r'^\d+\.\s*', '', trait)     # 번호 제거
-                        if len(trait) > 2:
-                            traits.append(trait)
-                if traits:
-                    break
-
-        return traits[:5]  # 최대 5개
-
-
-    def _process_character_content(self, content: str):
-        """Process character designer output with better error handling"""
-        try:
-            # Extract protagonist
-            protagonist_section = self._extract_section(content, r"(?:PROTAGONIST|주인공)")
-            if protagonist_section:
-                try:
-                    protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-                    self.screenplay_tracker.add_character(protagonist)
-                    ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-                except Exception as e:
-                    logger.error(f"Error parsing protagonist: {e}")
-                    # Create a default protagonist to continue
-                    protagonist = CharacterProfile(
-                        name="Protagonist",
-                        role="protagonist",
-                        archetype="Hero",
-                        want="To achieve goal",
-                        need="To grow",
-                        backstory="Unknown",
-                        personality=["Determined"],
-                        speech_pattern="Normal",
-                        character_arc="Growth"
-                    )
-                    self.screenplay_tracker.add_character(protagonist)
-            
-            # Extract antagonist
-            antagonist_section = self._extract_section(content, r"(?:ANTAGONIST|적대자)")
-            if antagonist_section:
-                try:
-                    antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-                    self.screenplay_tracker.add_character(antagonist)
-                    ScreenplayDatabase.save_character(self.current_session_id, antagonist)
-                except Exception as e:
-                    logger.error(f"Error parsing antagonist: {e}")
-                    # Create a default antagonist to continue
-                    antagonist = CharacterProfile(
-                        name="Antagonist",
-                        role="antagonist",
-                        archetype="Villain",
-                        want="To stop protagonist",
-                        need="Power",
-                        backstory="Unknown",
-                        personality=["Ruthless"],
-                        speech_pattern="Menacing",
-                        character_arc="Downfall"
-                    )
-                    self.screenplay_tracker.add_character(antagonist)
-            
-            # Extract supporting characters
-            supporting_section = self._extract_section(content, r"(?:SUPPORTING CAST|조력자들)")
-            if supporting_section:
-                # Parse multiple supporting characters
-                self._parse_supporting_characters(supporting_section)
-                
-        except Exception as e:
-            logger.error(f"Error processing character content: {e}")
-            # Continue with default values rather than failing
-
-    def _extract_section(self, content: str, section_pattern: str) -> str:
-        """Extract section from content with improved pattern matching"""
-        # More flexible section extraction
-        patterns = [
-            # Pattern 1: Section header followed by content until next major section
-            rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)',
-            # Pattern 2: Section header with content until next section (alternative)
-            rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)',
-            # Pattern 3: More flexible pattern for Korean text
-            rf'{section_pattern}[:\s]*\n?((?:[^\n]+\n?)*?)(?=\n\n|\Z)'
-        ]
-        
-        for pattern in patterns:
-            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-            if match and match.group(1):
-                section_content = match.group(1).strip()
-                if section_content:  # Only return if we got actual content
-                    return section_content
-        
-        return ""
-
-    def _parse_supporting_characters(self, content: str):
-        """Parse supporting characters from content"""
-        # Split by character markers (numbers or bullets)
-        char_sections = re.split(r'\n(?:\d+\.|[-•*])\s*', content)
-        
-        for i, section in enumerate(char_sections[1:], 1):  # Skip first empty split
-            if section.strip():
-                try:
-                    # Try multiple name extraction patterns
-                    name = None
-                    name_patterns = [
-                        r"(?:이름|Name)[:\s]*([^,\n]+)",
-                        r"^([^:\n]+?)(?:\s*[-–]\s*|:\s*)",  # Name at start before dash or colon
-                        r"^([가-힣A-Za-z\s]+?)(?:\s*\(|$)"  # Korean/English name before parenthesis
-                    ]
-                    
-                    for pattern in name_patterns:
-                        name_match = re.search(pattern, section.strip(), re.IGNORECASE)
-                        if name_match and name_match.group(1):
-                            name = name_match.group(1).strip()
-                            if name and len(name) > 1:
-                                break
-                    
-                    if not name:
-                        name = f"Supporting_{i}"
-                    
-                    role_desc = self._extract_field(section, r"(?:Role|역할)[:\s]*") or "supporting"
-                    
-                    character = CharacterProfile(
-                        name=name,
-                        role="supporting",
-                        archetype=role_desc,
-                        want="",
-                        need="",
-                        backstory=self._extract_field(section, r"(?:Backstory|백스토리)[:\s]*") or "",
-                        personality=[],
-                        speech_pattern="",
-                        character_arc=""
-                    )
-                    
-                    self.screenplay_tracker.add_character(character)
-                    ScreenplayDatabase.save_character(self.current_session_id, character)
-                    
-                except Exception as e:
-                    logger.warning(f"Error parsing supporting character {i}: {e}")
-                    continue
-
-    def _process_producer_content(self, content: str):
-        """Process producer output with better extraction"""
-        try:
-            # Extract title with various formats
-            title_patterns = [
-                r'(?:TITLE|제목)[:\s]*\*?\*?([^\n*]+)\*?\*?',
-                r'\*\*(?:TITLE|제목)\*\*[:\s]*([^\n]+)',
-                r'Title[:\s]*([^\n]+)'
-            ]
-            
-            for pattern in title_patterns:
-                title_match = re.search(pattern, content, re.IGNORECASE)
-                if title_match:
-                    self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
-                    break
-            
-            # Extract logline with various formats
-            logline_patterns = [
-                r'(?:LOGLINE|로그라인)[:\s]*\*?\*?([^\n]+)',
-                r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+)',
-                r'Logline[:\s]*([^\n]+)'
-            ]
-            
-            for pattern in logline_patterns:
-                logline_match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-                if logline_match:
-                    # Get full logline (might be multi-line)
-                    logline_text = logline_match.group(1).strip()
-                    # Continue reading if it's incomplete
-                    if not logline_text.endswith('.'):
-                        next_lines = content[logline_match.end():].split('\n')
-                        for line in next_lines[:3]:  # Check next 3 lines
-                            if line.strip() and not re.match(r'^[A-Z가-힣\d]', line.strip()):
-                                logline_text += ' ' + line.strip()
-                            else:
-                                break
-                    self.screenplay_tracker.screenplay_bible.logline = logline_text
-                    break
-            
-            # Extract genre
-            genre_match = re.search(r'(?:Primary Genre|주 장르)[:\s]*([^\n]+)', content, re.IGNORECASE)
-            if genre_match:
-                self.screenplay_tracker.screenplay_bible.genre = genre_match.group(1).strip()
-            
-            # Save to database
-            ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
-                                                   self.screenplay_tracker.screenplay_bible)
-                                                   
-        except Exception as e:
-            logger.error(f"Error processing producer content: {e}")
-
-    def _process_story_content(self, content: str):
-        """Process story developer output"""
-        # Extract three-act structure
-        self.screenplay_tracker.screenplay_bible.three_act_structure = {
-            "act1": self._extract_section(content, "ACT 1|제1막"),
-            "act2a": self._extract_section(content, "ACT 2A|제2막A"),
-            "act2b": self._extract_section(content, "ACT 2B|제2막B"),
-            "act3": self._extract_section(content, "ACT 3|제3막")
-        }
-        
-        ScreenplayDatabase.save_screenplay_bible(self.current_session_id,
-                                               self.screenplay_tracker.screenplay_bible)
-
-    def _process_scene_content(self, content: str):
-        """Process scene planner output"""
-        # Parse scene breakdown
-        scene_pattern = r'(?:Scene|씬)\s*(\d+).*?(?:INT\.|EXT\.)\s*(.+?)\s*-\s*(\w+)'
-        scenes = re.finditer(scene_pattern, content, re.IGNORECASE | re.MULTILINE)
-        
-        for match in scenes:
-            scene_num = int(match.group(1))
-            location = match.group(2).strip()
-            time_of_day = match.group(3).strip()
-            
-            # Determine act based on scene number
-            act = 1 if scene_num <= 12 else 2 if scene_num <= 35 else 3
-            
-            scene = SceneBreakdown(
-                scene_number=scene_num,
-                act=act,
-                location=location,
-                time_of_day=time_of_day,
-                characters=[],  # Would be extracted from content
-                purpose="",  # Would be extracted from content
-                conflict="",  # Would be extracted from content
-                page_count=1.5  # Default estimate
-            )
-            
-            self.screenplay_tracker.add_scene(scene)
-            ScreenplayDatabase.save_scene(self.current_session_id, scene)
-
-# --- Utility functions ---
-def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
-    """Generate random screenplay theme"""
-    try:
-        # Log the attempt
-        logger.info(f"Generating random theme - Type: {screenplay_type}, Genre: {genre}, Language: {language}")
-        
-        # Load themes data
-        themes_data = load_screenplay_themes_data()
-        
-        # Select random elements
-        import secrets
-        situations = themes_data['situations'].get(genre, themes_data['situations']['drama'])
-        protagonists = themes_data['protagonists'].get(genre, themes_data['protagonists']['drama'])
-        conflicts = themes_data['conflicts'].get(genre, themes_data['conflicts']['drama'])
-        
-        if not situations or not protagonists or not conflicts:
-            logger.error(f"No theme data available for genre {genre}")
-            return f"Error: No theme data available for genre {genre}"
-        
-        situation = secrets.choice(situations)
-        protagonist = secrets.choice(protagonists)
-        conflict = secrets.choice(conflicts)
-        
-        logger.info(f"Selected elements - Situation: {situation}, Protagonist: {protagonist}, Conflict: {conflict}")
-        
-        # Check if API token is valid
-        if not FRIENDLI_TOKEN or FRIENDLI_TOKEN == "dummy_token_for_testing":
-            logger.warning("No valid API token, returning fallback theme")
-            return get_fallback_theme(screenplay_type, genre, language, situation, protagonist, conflict)
-        
-        # Generate theme using LLM
-        system = ScreenplayGenerationSystem()
-        
-        if language == "Korean":
-            prompt = f"""다음 요소들로 {screenplay_type}용 매력적인 컨셉을 생성하세요:
-
-상황: {situation}
-주인공: {protagonist}
-갈등: {conflict}
-장르: {genre}
-
-다음 형식으로 작성:
-
-**제목:** [매력적인 제목]
-
-**로그라인:** [25단어 이내 한 문장]
-
-**컨셉:** [주인공]이(가) [상황]에서 [갈등]을 겪으며 [목표]를 추구하는 이야기.
-
-**독특한 요소:** [이 이야기만의 특별한 점]"""
-        else:
-            prompt = f"""Generate an attractive concept for {screenplay_type} using these elements:
-
-Situation: {situation}
-Protagonist: {protagonist}  
-Conflict: {conflict}
-Genre: {genre}
-
-Format as:
-
-**Title:** [Compelling title]
-
-**Logline:** [One sentence, 25 words max]
-
-**Concept:** A story about [protagonist] who faces [conflict] in [situation] while pursuing [goal].
-
-**Unique Element:** [What makes this story special]"""
-
-        messages = [{"role": "user", "content": prompt}]
-        
-        # Call LLM with error handling
-        logger.info("Calling LLM for theme generation...")
-        
-        generated_theme = ""
-        error_occurred = False
-        
-        # Use streaming to get the response
-        for chunk in system.call_llm_streaming(messages, "producer", language):
-            if chunk.startswith("❌"):
-                logger.error(f"LLM streaming error: {chunk}")
-                error_occurred = True
-                break
-            generated_theme += chunk
-        
-        # If error occurred or no content generated, use fallback
-        if error_occurred or not generated_theme.strip():
-            logger.warning("LLM call failed or empty response, using fallback theme")
-            return get_fallback_theme(screenplay_type, genre, language, situation, protagonist, conflict)
-        
-        logger.info(f"Successfully generated theme of length: {len(generated_theme)}")
-        
-        # Extract metadata
-        metadata = {
-            'title': extract_title_from_theme(generated_theme),
-            'logline': extract_logline_from_theme(generated_theme),
-            'protagonist': protagonist,
-            'conflict': conflict,
-            'situation': situation,
-            'tags': [genre, screenplay_type]
-        }
-        
-        # Save to database
-        try:
-            theme_id = ScreenplayDatabase.save_random_theme(
-                generated_theme, screenplay_type, genre, language, metadata
-            )
-            logger.info(f"Saved theme with ID: {theme_id}")
-        except Exception as e:
-            logger.error(f"Failed to save theme to database: {e}")
-        
-        return generated_theme
-        
-    except Exception as e:
-        logger.error(f"Theme generation error: {str(e)}")
-        import traceback
-        logger.error(traceback.format_exc())
-        return f"Error generating theme: {str(e)}"
-
-def get_fallback_theme(screenplay_type: str, genre: str, language: str, 
-                      situation: str, protagonist: str, conflict: str) -> str:
-    """Generate fallback theme without LLM"""
-    if language == "Korean":
-        return f"""**제목:** {protagonist}의 선택
-
-**로그라인:** {situation}에 갇힌 {protagonist}가 {conflict}에 맞서며 생존을 위해 싸운다.
-
-**컨셉:** {protagonist}가 {situation}에서 {conflict}을 겪으며 자신의 한계를 극복하는 이야기.
-
-**독특한 요소:** {genre} 장르의 전통적 요소를 현대적으로 재해석한 작품."""
-    else:
-        return f"""**Title:** The {protagonist.title()}'s Choice
-
-**Logline:** When trapped in {situation}, a {protagonist} must face {conflict} to survive.
-
-**Concept:** A story about a {protagonist} who faces {conflict} in {situation} while discovering their true strength.
-
-**Unique Element:** A fresh take on {genre} genre conventions with contemporary relevance."""
-
-def load_screenplay_themes_data() -> Dict:
-   """Load screenplay themes data"""
-   return {
-       'situations': {
-           'action': ['hostage crisis', 'heist gone wrong', 'revenge mission', 'race against time'],
-           'thriller': ['false accusation', 'witness protection', 'conspiracy uncovered', 'identity theft'],
-           'drama': ['family reunion', 'terminal diagnosis', 'divorce proceedings', 'career crossroads'],
-           'comedy': ['mistaken identity', 'wedding disaster', 'workplace chaos', 'odd couple roommates'],
-           'horror': ['isolated location', 'ancient curse', 'home invasion', 'supernatural investigation'],
-           'sci-fi': ['first contact', 'time loop', 'AI awakening', 'space colony crisis'],
-           'romance': ['second chance', 'enemies to lovers', 'long distance', 'forbidden love']
-       },
-       'protagonists': {
-           'action': ['ex-soldier', 'undercover cop', 'skilled thief', 'reluctant hero'],
-           'thriller': ['investigative journalist', 'wrongly accused person', 'FBI agent', 'whistleblower'],
-           'drama': ['single parent', 'recovering addict', 'immigrant', 'caregiver'],
-           'comedy': ['uptight professional', 'slacker', 'fish out of water', 'eccentric artist'],
-           'horror': ['skeptical scientist', 'final girl', 'paranormal investigator', 'grieving parent'],
-           'sci-fi': ['astronaut', 'AI researcher', 'time traveler', 'colony leader'],
-           'romance': ['workaholic', 'hopeless romantic', 'cynical divorce lawyer', 'small town newcomer']
-       },
-       'conflicts': {
-           'action': ['stop the villain', 'save the hostages', 'prevent disaster', 'survive pursuit'],
-           'thriller': ['prove innocence', 'expose truth', 'stay alive', 'protect loved ones'],
-           'drama': ['reconcile past', 'find purpose', 'heal relationships', 'accept change'],
-           'comedy': ['save the business', 'win the competition', 'fool everyone', 'find love'],
-           'horror': ['survive the night', 'break the curse', 'escape the monster', 'save the town'],
-           'sci-fi': ['save humanity', 'prevent paradox', 'stop the invasion', 'preserve identity'],
-           'romance': ['overcome differences', 'choose between options', 'trust again', 'follow heart']
-       }
-   }
-
-def extract_title_from_theme(theme_text: str) -> str:
-   """Extract title from generated theme"""
-   match = re.search(r'\*\*(?:Title|제목):\*\*\s*(.+)', theme_text, re.IGNORECASE)
-   return match.group(1).strip() if match else ""
-
-def extract_logline_from_theme(theme_text: str) -> str:
-   """Extract logline from generated theme"""
-   match = re.search(r'\*\*(?:Logline|로그라인):\*\*\s*(.+)', theme_text, re.IGNORECASE)
-   return match.group(1).strip() if match else ""
-
-def format_screenplay_display(screenplay_text: str) -> str:
-   """Format screenplay for display"""
-   if not screenplay_text:
-       return "No screenplay content yet."
-   
-   formatted = "# 🎬 Screenplay\n\n"
-   
-   # Format scene headings
-   formatted_text = re.sub(
-       r'^(INT\.|EXT\.)(.*?),
-       r'**\1\2**',
-       screenplay_text,
-       flags=re.MULTILINE
-   )
-   
-   # Format character names (all caps on their own line)
-   formatted_text = re.sub(
-       r'^([A-Z][A-Z\s]+),
-       r'**\1**',
-       formatted_text,
-       flags=re.MULTILINE
-   )
-   
-   # Add spacing for readability
-   lines = formatted_text.split('\n')
-   formatted_lines = []
-   
-   for i, line in enumerate(lines):
-       formatted_lines.append(line)
-       # Add extra space after scene headings
-       if line.startswith('**INT.') or line.startswith('**EXT.'):
-           formatted_lines.append('')
-   
-   formatted += '\n'.join(formatted_lines)
-   
-   # Add page count
-   page_count = len(screenplay_text.split('\n')) / 55
-   formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted
-   
-   return formatted
-
-def format_stages_display(stages: List[Dict]) -> str:
-   """Format stages display for screenplay"""
-   markdown = "## 🎬 Production Progress\n\n"
-   
-   # Progress summary
-   completed = sum(1 for s in stages if s.get('status') == 'complete')
-   total = len(stages)
-   markdown += f"**Progress: {completed}/{total} stages complete**\n\n"
-   
-   # Page count if available
-   total_pages = sum(s.get('page_count', 0) for s in stages if s.get('page_count'))
-   if total_pages > 0:
-       markdown += f"**Current Page Count: {total_pages:.1f} pages**\n\n"
-   
-   markdown += "---\n\n"
-   
-   # Stage details
-   current_act = None
-   for i, stage in enumerate(stages):
-       status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
-       
-       # Group by acts
-       if 'Act' in stage.get('name', ''):
-           act_match = re.search(r'Act (\w+)', stage['name'])
-           if act_match and act_match.group(1) != current_act:
-               current_act = act_match.group(1)
-               markdown += f"\n### 📄 Act {current_act}\n\n"
-       
-       markdown += f"{status_icon} **{stage['name']}**"
-       
-       if stage.get('page_count', 0) > 0:
-           markdown += f" ({stage['page_count']:.1f} pages)"
-       
-       markdown += "\n"
-       
-       if stage['content'] and stage['status'] == 'complete':
-           preview_length = 200
-           preview = stage['content'][:preview_length] + "..." if len(stage['content']) > preview_length else stage['content']
-           markdown += f"> {preview}\n\n"
-       elif stage['status'] == 'active':
-           markdown += "> *In progress...*\n\n"
-   
-   return markdown
-
-def process_query(query: str, screenplay_type: str, genre: str, language: str, 
-                session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
-   """Main query processing function"""
-   if not query.strip():
-       yield "", "", "❌ Please enter a screenplay concept.", session_id
-       return
-   
-   system = ScreenplayGenerationSystem()
-   stages_markdown = ""
-   screenplay_display = ""
-   
-   for status, stages, current_session_id in system.process_screenplay_stream(
-       query, screenplay_type, genre, language, session_id
-   ):
-       stages_markdown = format_stages_display(stages)
-       
-       # Get screenplay content when available
-       if stages and all(s.get("status") == "complete" for s in stages[-4:]):
-           screenplay_text = ScreenplayDatabase.get_screenplay_content(current_session_id)
-           screenplay_display = format_screenplay_display(screenplay_text)
-       
-       yield stages_markdown, screenplay_display, status or "🔄 Processing...", current_session_id
-
-def get_active_sessions() -> List[str]:
-   """Get active screenplay sessions"""
-   sessions = ScreenplayDatabase.get_active_sessions()
-   return [
-       f"{s['session_id'][:8]}... - {s.get('title', s['user_query'][:30])}... "
-       f"({s['screenplay_type']}/{s['genre']}) [{s['total_pages']:.1f} pages]"
-       for s in sessions
-   ]
-
-def export_screenplay_pdf(screenplay_text: str, title: str, session_id: str) -> str:
-   """Export screenplay to PDF format"""
-   # This would use a library like reportlab to create industry-standard PDF
-   # For now, returning a placeholder
-   pdf_path = f"screenplay_{session_id[:8]}.pdf"
-   # PDF generation logic would go here
-   return pdf_path
-
-def export_screenplay_fdx(screenplay_text: str, title: str, session_id: str) -> str:
-   """Export to Final Draft format"""
-   # This would create .fdx XML format
-   fdx_path = f"screenplay_{session_id[:8]}.fdx"
-   # FDX generation logic would go here
-   return fdx_path
-
-def download_screenplay(screenplay_text: str, format_type: str, title: str, 
-                      session_id: str) -> Optional[str]:
-   """Generate screenplay download file"""
-   if not screenplay_text or not session_id:
-       return None
-   
-   timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-   
-   try:
-       if format_type == "PDF":
-           return export_screenplay_pdf(screenplay_text, title, session_id)
-       elif format_type == "FDX":
-           return export_screenplay_fdx(screenplay_text, title, session_id)
-       elif format_type == "FOUNTAIN":
-           filepath = f"screenplay_{session_id[:8]}_{timestamp}.fountain"
-           with open(filepath, 'w', encoding='utf-8') as f:
-               f.write(screenplay_text)
-           return filepath
-       else:  # TXT
-           filepath = f"screenplay_{session_id[:8]}_{timestamp}.txt"
-           with open(filepath, 'w', encoding='utf-8') as f:
-               f.write(f"Title: {title}\n")
-               f.write("=" * 50 + "\n\n")
-               f.write(screenplay_text)
-           return filepath
-   except Exception as e:
-       logger.error(f"Download generation failed: {e}")
-       return None
-
-# Create Gradio interface
-def create_interface():
-   """Create Gradio interface for screenplay generation"""
-   
-   css = """
-   .main-header {
-       text-align: center;
-       margin-bottom: 2rem;
-       padding: 2rem;
-       background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
-       border-radius: 10px;
-       color: white;
-   }
-   
-   .header-title {
-       font-size: 3rem;
-       margin-bottom: 1rem;
-       background: linear-gradient(45deg, #f39c12, #e74c3c);
-       -webkit-background-clip: text;
-       -webkit-text-fill-color: transparent;
-   }
-   
-   .header-description {
-       font-size: 1.1rem;
-       opacity: 0.9;
-       line-height: 1.6;
-   }
-   
-   .type-selector {
-       display: flex;
-       gap: 1rem;
-       margin: 1rem 0;
-   }
-   
-   .type-card {
-       flex: 1;
-       padding: 1rem;
-       border: 2px solid #ddd;
-       border-radius: 8px;
-       cursor: pointer;
-       transition: all 0.3s;
-   }
-   
-   .type-card:hover {
-       border-color: #f39c12;
-       transform: translateY(-2px);
-   }
-   
-   .type-card.selected {
-       border-color: #e74c3c;
-       background: #fff5f5;
-   }
-   
-   #stages-display {
-       max-height: 600px;
-       overflow-y: auto;
-       padding: 1rem;
-       background: #f8f9fa;
-       border-radius: 8px;
-   }
-   
-   #screenplay-output {
-       font-family: 'Courier New', monospace;
-       white-space: pre-wrap;
-       background: white;
-       padding: 2rem;
-       border: 1px solid #ddd;
-       border-radius: 8px;
-       max-height: 800px;
-       overflow-y: auto;
-   }
-   
-   .genre-grid {
-       display: grid;
-       grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-       gap: 0.5rem;
-       margin: 1rem 0;
-   }
-   
-   .genre-btn {
-       padding: 0.75rem;
-       border: 2px solid #e0e0e0;
-       background: white;
-       border-radius: 8px;
-       cursor: pointer;
-       transition: all 0.3s;
-       text-align: center;
-   }
-   
-   .genre-btn:hover {
-       border-color: #f39c12;
-       background: #fffbf0;
-   }
-   
-   .genre-btn.selected {
-       border-color: #e74c3c;
-       background: #fff5f5;
-       font-weight: bold;
-   }
-   """
-   
-   with gr.Blocks(theme=gr.themes.Soft(), css=css, title="Screenplay Generator") as interface:
-       gr.HTML("""
-       <div class="main-header">
-           <h1 class="header-title">🎬 AI Screenplay Generator</h1>
-           <p class="header-description">
-               Transform your ideas into professional screenplays for films, TV shows, and streaming series.
-               Using industry-standard format and story structure to create compelling, producible scripts.
-           </p>
-       </div>
-       """)
-       
-       # State management
-       current_session_id = gr.State(None)
-       
-       with gr.Tabs():
-           # Main Writing Tab
-           with gr.Tab("✍️ Write Screenplay"):
-               with gr.Row():
-                   with gr.Column(scale=3):
-                       query_input = gr.Textbox(
-                           label="Screenplay Concept",
-                           placeholder="""Describe your screenplay idea. For example:
-- A detective with memory loss must solve their own attempted murder
-- Two rival food truck owners forced to work together to save the city food festival  
-- A space station AI develops consciousness during a critical mission
-- A family reunion turns into a murder mystery during a hurricane
-
-The more specific your concept, the better the screenplay will be tailored to your vision.""",
-                           lines=6
-                       )
-                   
-                   with gr.Column(scale=1):
-                       screenplay_type = gr.Radio(
-                           choices=list(SCREENPLAY_LENGTHS.keys()),
-                           value="movie",
-                           label="Screenplay Type",
-                           info="Choose your format"
-                       )
-                       
-                       genre_select = gr.Dropdown(
-                           choices=list(GENRE_TEMPLATES.keys()),
-                           value="drama",
-                           label="Primary Genre",
-                           info="Select main genre"
-                       )
-                       
-                       language_select = gr.Radio(
-                           choices=["English", "Korean"],
-                           value="English",
-                           label="Language"
-                       )
-               
-               with gr.Row():
-                   random_btn = gr.Button("🎲 Random Concept", scale=1)
-                   clear_btn = gr.Button("🗑️ Clear", scale=1)
-                   submit_btn = gr.Button("🎬 Start Writing", variant="primary", scale=2)
-               
-               status_text = gr.Textbox(
-                   label="Status",
-                   interactive=False,
-                   value="Ready to create your screenplay"
-               )
-               
-               # Session management
-               with gr.Group():
-                   gr.Markdown("### 📁 Saved Projects")
-                   with gr.Row():
-                       session_dropdown = gr.Dropdown(
-                           label="Active Sessions",
-                           choices=[],
-                           interactive=True,
-                           scale=3
-                       )
-                       refresh_btn = gr.Button("🔄", scale=1)
-                       resume_btn = gr.Button("📂 Load", scale=1)
-               
-               # Output displays
-               with gr.Row():
-                   with gr.Column():
-                       with gr.Tab("🎭 Writing Progress"):
-                           stages_display = gr.Markdown(
-                               value="*Your screenplay journey will unfold here...*",
-                               elem_id="stages-display"
-                           )
-                       
-                       with gr.Tab("📄 Screenplay"):
-                           screenplay_output = gr.Markdown(
-                               value="*Your formatted screenplay will appear here...*",
-                               elem_id="screenplay-output"
-                           )
-                           
-                           with gr.Row():
-                               format_select = gr.Radio(
-                                   choices=["PDF", "FDX", "FOUNTAIN", "TXT"],
-                                   value="PDF",
-                                   label="Export Format"
-                               )
-                               download_btn = gr.Button("📥 Download Screenplay", variant="secondary")
-                           
-                           download_file = gr.File(
-                               label="Download",
-                               visible=False
-                           )
-               
-               # Examples
-               gr.Examples(
-                   examples=[
-                       ["A burned-out teacher discovers her students are being replaced by AI duplicates"],
-                       ["Two funeral home employees accidentally release a ghost who helps them solve murders"],
-                       ["A time-loop forces a wedding planner to relive the worst wedding until they find true love"],
-                       ["An astronaut returns to Earth to find everyone has forgotten space exists"],
-                       ["A support group for reformed villains must save the city when heroes disappear"],
-                       ["A food critic loses their sense of taste and teams up with a street food vendor"]
-                   ],
-                   inputs=query_input,
-                   label="💡 Example Concepts"
-               )
-           
-           # Screenplay Library Tab
-           with gr.Tab("📚 Concept Library"):
-               gr.Markdown("""
-               ### 🎲 Random Screenplay Concepts
-               
-               Browse through AI-generated screenplay concepts. Each concept includes a title, logline, and brief setup.
-               """)
-               
-               library_display = gr.HTML(
-                   value="<p>Library feature coming soon...</p>"
-               )
-       
-       # Event handlers
-       def handle_submit(query, s_type, genre, lang, session_id):
-           if not query:
-               yield "", "", "❌ Please enter a concept", session_id
-               return
-           
-           yield from process_query(query, s_type, genre, lang, session_id)
-       
-       def handle_random(s_type, genre, lang):
-           return generate_random_screenplay_theme(s_type, genre, lang)
-       
-       def handle_download(screenplay_text, format_type, session_id):
-           if not screenplay_text or not session_id:
-               return gr.update(visible=False)
-           
-           # Get title from database
-           session = ScreenplayDatabase.get_session(session_id)
-           title = session.get('title', 'Untitled') if session else 'Untitled'
-           
-           file_path = download_screenplay(screenplay_text, format_type, title, session_id)
-           if file_path and os.path.exists(file_path):
-               return gr.update(value=file_path, visible=True)
-           return gr.update(visible=False)
-       
-       # Connect events
-       submit_btn.click(
-           fn=handle_submit,
-           inputs=[query_input, screenplay_type, genre_select, language_select, current_session_id],
-           outputs=[stages_display, screenplay_output, status_text, current_session_id]
-       )
-       
-       random_btn.click(
-           fn=handle_random,
-           inputs=[screenplay_type, genre_select, language_select],
-           outputs=[query_input]
-       )
-       
-       clear_btn.click(
-           fn=lambda: ("", "", "Ready to create your screenplay", None),
-           outputs=[stages_display, screenplay_output, status_text, current_session_id]
-       )
-       
-       refresh_btn.click(
-           fn=get_active_sessions,
-           outputs=[session_dropdown]
-       )
-       
-       download_btn.click(
-           fn=handle_download,
-           inputs=[screenplay_output, format_select, current_session_id],
-           outputs=[download_file]
-       )
-       
-       # Load sessions on start
-       interface.load(
-           fn=get_active_sessions,
-           outputs=[session_dropdown]
-       )
-   
-   return interface
-
 # Main function
 if __name__ == "__main__":
    logger.info("Screenplay Generator Starting...")
@@ -3979,3 +2869,4 @@ if __name__ == "__main__":
        share=False,
        debug=True
    )
+