Update app.py

app.py

@@ -536,18 +536,6 @@ class ScreenplayDatabase:
         
         return theme_id
 
-    @staticmethod
-    def get_stages(session_id: str) -> List[Dict]:
-        """Get all stages for a session"""
-        with ScreenplayDatabase.get_db() as conn:
-            rows = conn.cursor().execute(
-                '''SELECT * FROM screenplay_stages 
-                   WHERE session_id = ? 
-                   ORDER BY stage_number''', 
-                (session_id,)
-            ).fetchall()
-            return [dict(row) for row in rows]
-
 class WebSearchIntegration:
    """Web search functionality for screenplay research"""
    def __init__(self):
@@ -1481,8 +1469,6 @@ Provide specific solutions for each issue."""
             raise Exception(f"LLM Call Failed: {full_content}")
         return full_content
 
-
-
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
                           language: str) -> Generator[str, None, None]:
         try:
@@ -1632,8 +1618,6 @@ Provide specific solutions for each issue."""
             logger.error(traceback.format_exc())
             yield f"❌ Unexpected error: {str(e)}"
 
-
-
     def get_system_prompts(self, language: str) -> Dict[str, str]:
         """Role-specific system prompts"""
         
@@ -1724,9 +1708,7 @@ You provide feedback that's critical yet encouraging."""
         
         return base_prompts.get(language, base_prompts["English"])
 
-
-
-# --- Main process ---
+    # --- Main process ---
     def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
                                 language: str, session_id: Optional[str] = None
                                 ) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
@@ -1886,6 +1868,20 @@ You provide feedback that's critical yet encouraging."""
         
         return "\n\n---\n\n".join(previous) if previous else ""
 
+    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
+        """Extract field value from content with improved parsing"""
+        # More flexible pattern that handles various formats
+        pattern = rf'{field_pattern}[:\s]*([^\n]+?)(?=\n[A-Z가-힣]|$)'
+        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+        if match and match.group(1):  # Check if group(1) exists and is not None
+            value = match.group(1).strip()
+            # Remove markdown formatting if present
+            value = re.sub(r'\*\*', '', value)
+            value = re.sub(r'^\s*[-•]\s*', '', value)
+            # Remove trailing punctuation
+            value = re.sub(r'[,.:;], '', value)
+            return value.strip() if value else None
+        return None
 
     def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
         """Parse character profile from content"""
@@ -1903,10 +1899,10 @@ You provide feedback that's critical yet encouraging."""
         
         for pattern in name_patterns:
             name_match = re.search(pattern, content, re.IGNORECASE | re.MULTILINE)
-            if name_match:
+            if name_match and name_match.group(1):
                 extracted_name = name_match.group(1).strip()
                 # Remove markdown and extra characters
-                extracted_name = re.sub(r'[*:\s]+$', '', extracted_name)
+                extracted_name = re.sub(r'[*:\s]+, '', extracted_name)
                 extracted_name = re.sub(r'^[*:\s]+', '', extracted_name)
                 if extracted_name and len(extracted_name) > 1:
                     name = extracted_name
@@ -1918,8 +1914,9 @@ You provide feedback that's critical yet encouraging."""
                 patterns = [patterns]
             
             for pattern in patterns:
+                # Improved pattern with better capturing groups
                 match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, re.IGNORECASE | re.DOTALL)
-                if match:
+                if match and match.group(1):
                     value = match.group(1).strip()
                     # Clean up the value
                     value = re.sub(r'^[-*•:\s]+', '', value)
@@ -1929,7 +1926,7 @@ You provide feedback that's critical yet encouraging."""
                         return value
             return ""
         
-        # Extract all fields
+        # Extract all fields with safer extraction
         profile = CharacterProfile(
             name=name,
             role=role,
@@ -1975,166 +1972,211 @@ You provide feedback that's critical yet encouraging."""
         logger.debug(f"Parsed character: {profile.name}")
         return profile
 
-    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-        """Extract field value from content with improved parsing"""
-        # Use word boundary to prevent partial matches
-        pattern = rf'\b{field_pattern}\b[:\s]*([^\n]+?)(?=\n|$)'
-        match = re.search(pattern, content, re.IGNORECASE)
-        if match:
-            value = match.group(1).strip()
-            # Remove markdown formatting
-            value = re.sub(r'\*+', '', value)
-            # Remove list markers
-            value = re.sub(r'^\s*[-•*]\s*', '', value)
-            # Remove trailing punctuation
-            value = re.sub(r'[,.:;]$', '', value)
-            return value.strip()
-        return None
-
     def _extract_personality_traits(self, content: str) -> List[str]:
-       """Extract personality traits from content"""
-       traits = []
-       # Look for personality section
-       personality_section = self._extract_field(content, r"(?:Personality|성격)[:\s]*")
-       if personality_section:
-           # Extract individual traits (usually listed)
-           trait_lines = personality_section.split('\n')
-           for line in trait_lines:
-               line = line.strip()
-               if line and not line.endswith(':'):
-                   # Remove list markers
-                   trait = re.sub(r'^\s*[-•*]\s*', '', line)
-                   if trait:
-                       traits.append(trait)
-       return traits[:5]  # Limit to 5 traits
+        """Extract personality traits from content"""
+        traits = []
+        # Look for personality section with multiple pattern options
+        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):
+                personality_section = match.group(1)
+                # Extract individual traits (usually listed)
+                trait_lines = personality_section.split('\n')
+                for line in trait_lines:
+                    line = line.strip()
+                    if line and not line.endswith(':'):
+                        # Remove list markers
+                        trait = re.sub(r'^\s*[-•*]\s*', '', line)
+                        trait = re.sub(r'^\d+\.\s*', '', trait)  # Remove numbered lists
+                        if trait and len(trait) > 2:  # Skip very short entries
+                            traits.append(trait)
+                if traits:  # If we found traits, stop looking
+                    break
+        
+        return traits[:5]  # Limit to 5 traits
 
     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:
-               protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-               self.screenplay_tracker.add_character(protagonist)
-               ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-           
-           # Extract antagonist
-           antagonist_section = self._extract_section(content, r"(?:ANTAGONIST|적대자)")
-           if antagonist_section:
-               antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-               self.screenplay_tracker.add_character(antagonist)
-               ScreenplayDatabase.save_character(self.current_session_id, 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 _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:
-                   name = self._extract_field(section, r"(?:Name|이름)[:\s]*") or f"Supporting_{i}"
-                   role = self._extract_field(section, r"(?:Role|역할)[:\s]*") or "supporting"
-                   
-                   character = CharacterProfile(
-                       name=name,
-                       role="supporting",
-                       archetype=role,
-                       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
+        """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
-       pattern = rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)'
-       match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-       if match:
-           return match.group(1).strip()
-       
-       # Try alternative pattern
-       pattern2 = rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)'
-       match2 = re.search(pattern2, content, re.IGNORECASE | re.DOTALL)
-       if match2:
-           return match2.group(1).strip()
-       
-       return ""
-
-    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}")
-
-
+        """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"""
@@ -2149,22 +2191,6 @@ You provide feedback that's critical yet encouraging."""
         ScreenplayDatabase.save_screenplay_bible(self.current_session_id,
                                                self.screenplay_tracker.screenplay_bible)
 
-    def _process_character_content(self, content: str):
-        """Process character designer output"""
-        # Extract protagonist
-        protagonist_section = self._extract_section(content, "PROTAGONIST|주인공")
-        if protagonist_section:
-            protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-            self.screenplay_tracker.add_character(protagonist)
-            ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-        
-        # Extract antagonist
-        antagonist_section = self._extract_section(content, "ANTAGONIST|적대자")
-        if antagonist_section:
-            antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-            self.screenplay_tracker.add_character(antagonist)
-            ScreenplayDatabase.save_character(self.current_session_id, antagonist)
-
     def _process_scene_content(self, content: str):
         """Process scene planner output"""
         # Parse scene breakdown
@@ -2193,44 +2219,6 @@ You provide feedback that's critical yet encouraging."""
             self.screenplay_tracker.add_scene(scene)
             ScreenplayDatabase.save_scene(self.current_session_id, scene)
 
-    def _extract_section(self, content: str, section_pattern: str) -> str:
-        """Extract section from content"""
-        pattern = rf'(?:{section_pattern})[:\s]*(.+?)(?=\n(?:[A-Z]{{2,}}|[가-힣]{{2,}}):|\Z)'
-        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-        return match.group(1).strip() if match else ""
-
-    def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-        """Parse character profile from content"""
-        # Extract character details using regex or string parsing
-        name = self._extract_field(content, "Name|이름") or f"Character_{role}"
-        
-        return CharacterProfile(
-            name=name,
-            role=role,
-            archetype=self._extract_field(content, "Archetype|아크타입") or "",
-            want=self._extract_field(content, "WANT|외적 목표") or "",
-            need=self._extract_field(content, "NEED|내적 필요") or "",
-            backstory=self._extract_field(content, "Backstory|백스토리") or "",
-            personality=[],  # Would be parsed from content
-            speech_pattern=self._extract_field(content, "Speech|말투") or "",
-            character_arc=self._extract_field(content, "Arc|아크") or ""
-        )
-
-    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-        """Extract field value from content with improved parsing"""
-        # More flexible pattern that handles various formats
-        pattern = rf'{field_pattern}(.+?)(?=\n[A-Z가-힣]|$)'
-        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-        if match:
-            value = match.group(1).strip()
-            # Remove markdown formatting if present
-            value = re.sub(r'\*\*', '', value)
-            value = re.sub(r'^\s*[-•]\s*', '', value)
-            # Remove trailing punctuation
-            value = re.sub(r'[,.:;]$', '', value)
-            return value.strip()
-        return None
-
 # --- Utility functions ---
 def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
     """Generate random screenplay theme"""
@@ -2421,7 +2409,7 @@ def format_screenplay_display(screenplay_text: str) -> str:
    
    # Format scene headings
    formatted_text = re.sub(
-       r'^(INT\.|EXT\.)(.*?)$',
+       r'^(INT\.|EXT\.)(.*?),
        r'**\1\2**',
        screenplay_text,
        flags=re.MULTILINE
@@ -2429,7 +2417,7 @@ def format_screenplay_display(screenplay_text: str) -> str:
    
    # Format character names (all caps on their own line)
    formatted_text = re.sub(
-       r'^([A-Z][A-Z\s]+)$',
+       r'^([A-Z][A-Z\s]+),
        r'**\1**',
        formatted_text,
        flags=re.MULTILINE
@@ -2897,4 +2885,4 @@ if __name__ == "__main__":
        server_port=7860,
        share=False,
        debug=True
-   )                                            
+   )