Update app.py

app.py

@@ -211,38 +211,45 @@ class CharacterProfile:
 
 # --- Core logic classes ---
 class ScreenplayTracker:
-   """Unified screenplay tracker"""
-   def __init__(self):
-       self.screenplay_bible = ScreenplayBible()
-       self.scenes: List[SceneBreakdown] = []
-       self.characters: Dict[str, CharacterProfile] = {}
-       self.page_count = 0
-       self.act_pages = {"1": 0, "2A": 0, "2B": 0, "3": 0}
-       self.dialogue_action_ratio = 0.0
-       
-   def add_scene(self, scene: SceneBreakdown):
-       """Add scene to tracker"""
-       self.scenes.append(scene)
-       self.page_count += scene.page_count
-       
-   def add_character(self, character: CharacterProfile):
-       """Add character to tracker"""
-       self.characters[character.name] = character
-       
-   def update_bible(self, key: str, value: Any):
-       """Update screenplay bible"""
-       if hasattr(self.screenplay_bible, key):
-           setattr(self.screenplay_bible, key, value)
-           
-   def get_act_page_target(self, act: str, total_pages: int) -> int:
-       """Get target pages for each act"""
-       if act == "1":
-           return int(total_pages * 0.25)
-       elif act in ["2A", "2B"]:
-           return int(total_pages * 0.25)
-       elif act == "3":
-           return int(total_pages * 0.25)
-       return 0
+    """Unified screenplay tracker"""
+    def __init__(self):
+        self.screenplay_bible = ScreenplayBible()
+        self.scenes: List[SceneBreakdown] = []
+        self.characters: Dict[str, CharacterProfile] = {}
+        self.page_count = 0
+        self.act_pages = {"1": 0, "2A": 0, "2B": 0, "3": 0}
+        self.dialogue_action_ratio = 0.0
+        
+    def add_scene(self, scene: SceneBreakdown):
+        """Add scene to tracker"""
+        self.scenes.append(scene)
+        self.page_count += scene.page_count
+        
+    def add_character(self, character: CharacterProfile):
+        """Add character to tracker"""
+        self.characters[character.name] = character
+        # Update bible with main characters
+        if character.role == "protagonist":
+            self.screenplay_bible.protagonist = asdict(character)
+        elif character.role == "antagonist":
+            self.screenplay_bible.antagonist = asdict(character)
+        elif character.role == "supporting":
+            self.screenplay_bible.supporting_cast[character.name] = asdict(character)
+        
+    def update_bible(self, key: str, value: Any):
+        """Update screenplay bible"""
+        if hasattr(self.screenplay_bible, key):
+            setattr(self.screenplay_bible, key, value)
+            
+    def get_act_page_target(self, act: str, total_pages: int) -> int:
+        """Get target pages for each act"""
+        if act == "1":
+            return int(total_pages * 0.25)
+        elif act in ["2A", "2B"]:
+            return int(total_pages * 0.25)
+        elif act == "3":
+            return int(total_pages * 0.25)
+        return 0
 
 class ScreenplayDatabase:
     """Database management for screenplay sessions"""
@@ -1622,183 +1629,189 @@ You consider all perspectives: producers, actors, audience.
 You provide feedback that's critical yet encouraging."""
             }
         }
-        
-        return base_prompts.get(language, base_prompts["English"])
 
-    # --- 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]:
-        """Main screenplay generation process"""
-        try:
-            resume_from_stage = 0
-            if session_id:
-                self.current_session_id = session_id
-                session = ScreenplayDatabase.get_session(session_id)
-                if session:
-                    query = session['user_query']
-                    screenplay_type = session['screenplay_type']
-                    genre = session['genre']
-                    language = session['language']
-                    resume_from_stage = session['current_stage'] + 1
-            else:
-                self.current_session_id = ScreenplayDatabase.create_session(
-                    query, screenplay_type, genre, language
-                )
-                logger.info(f"Created new screenplay session: {self.current_session_id}")
-
-            stages = []
-            if resume_from_stage > 0:
-                # Get existing stages from database
-                db_stages = ScreenplayDatabase.get_stages(self.current_session_id)
-                stages = [{
-                    "name": s['stage_name'], 
-                    "status": s['status'], 
-                    "content": s.get('content', ''),
-                    "page_count": s.get('page_count', 0)
-                } for s in db_stages]
-
-            for stage_idx in range(resume_from_stage, len(SCREENPLAY_STAGES)):
-                role, stage_name = SCREENPLAY_STAGES[stage_idx]
-                
-                if stage_idx >= len(stages):
-                    stages.append({
-                        "name": stage_name, 
-                        "status": "active", 
-                        "content": "", 
-                        "page_count": 0
-                    })
-                else:
-                    stages[stage_idx]["status"] = "active"
-
-                yield f"🔄 Processing {stage_name}...", stages, self.current_session_id
-                
-                prompt = self.get_stage_prompt(stage_idx, role, query, screenplay_type, 
-                                             genre, language, stages)
-                stage_content = ""
-                
-                for chunk in self.call_llm_streaming([{"role": "user", "content": prompt}], 
-                                                   role, language):
-                    stage_content += chunk
-                    stages[stage_idx]["content"] = stage_content
-                    if role == "screenwriter":
-                        stages[stage_idx]["page_count"] = len(stage_content.split('\n')) / 55
-                    yield f"🔄 {stage_name} in progress...", stages, self.current_session_id
-
-                # Process content based on role
-                if role == "producer":
-                    self._process_producer_content(stage_content)
-                elif role == "story_developer":
-                    self._process_story_content(stage_content)
-                elif role == "character_designer":
-                    self._process_character_content(stage_content)
-                elif role == "scene_planner":
-                    self._process_scene_content(stage_content)
-
-                stages[stage_idx]["status"] = "complete"
-                ScreenplayDatabase.save_stage(
-                    self.current_session_id, stage_idx, stage_name, role,
-                    stage_content, "complete"
-                )
-                
-                yield f"✅ {stage_name} completed", stages, self.current_session_id
+    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, r"(?:Name|이름)[:\s]*") or f"Character_{role}"
+       
+       # Extract age with better parsing
+       age_str = self._extract_field(content, r"(?:Age|나이)[:\s]*") or "30"
+       # Extract just the number from age string
+       age_match = re.search(r'\d+', age_str)
+       age = int(age_match.group()) if age_match else 30
+       
+       return CharacterProfile(
+           name=name,
+           age=age,
+           role=role,
+           archetype=self._extract_field(content, r"(?:Archetype|아크타입)[:\s]*") or "",
+           want=self._extract_field(content, r"(?:WANT|외적 목표)[:\s]*") or "",
+           need=self._extract_field(content, r"(?:NEED|내적 필요)[:\s]*") or "",
+           backstory=self._extract_field(content, r"(?:Backstory|백스토리)[:\s]*") or "",
+           personality=self._extract_personality_traits(content),
+           speech_pattern=self._extract_field(content, r"(?:Speech Pattern|말투)[:\s]*") or "",
+           character_arc=self._extract_field(content, r"(?:Arc|아크|Character Arc)[:\s]*") or ""
+       )
 
-            # Final processing
-            final_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
-            title = self.screenplay_tracker.screenplay_bible.title
-            logline = self.screenplay_tracker.screenplay_bible.logline
-            
-            ScreenplayDatabase.update_final_screenplay(
-                self.current_session_id, final_screenplay, title, logline
-            )
-            
-            yield f"✅ Screenplay completed! {title}", stages, self.current_session_id
+    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)
+           return value.strip()
+       return None
 
-        except Exception as e:
-            logger.error(f"Screenplay generation error: {e}", exc_info=True)
-            yield f"❌ Error occurred: {e}", stages if 'stages' in locals() else [], self.current_session_id
-
-    def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
-                        screenplay_type: str, genre: str, language: str, 
-                        stages: List[Dict]) -> str:
-        """Generate stage-specific prompt"""
-        if stage_idx == 0:  # Producer
-            return self.create_producer_prompt(query, screenplay_type, genre, language)
-        
-        if stage_idx == 1:  # Story Developer
-            return self.create_story_developer_prompt(
-                stages[0]["content"], query, screenplay_type, genre, language
-            )
-        
-        if stage_idx == 2:  # Character Designer
-            return self.create_character_designer_prompt(
-                stages[0]["content"], stages[1]["content"], genre, language
-            )
-        
-        if stage_idx == 3:  # Structure Critic
-            return self.create_critic_structure_prompt(
-                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
-            )
-        
-        if stage_idx == 4:  # Scene Planner
-            return self.create_scene_planner_prompt(
-                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
-            )
-        
-        # Screenwriter acts
-        if role == "screenwriter":
-            act_mapping = {5: "Act 1", 7: "Act 2A", 9: "Act 2B", 11: "Act 3"}
-            if stage_idx in act_mapping:
-                act = act_mapping[stage_idx]
-                previous_acts = self._get_previous_acts(stages, stage_idx)
-                return self.create_screenwriter_prompt(
-                    act, stages[4]["content"], stages[2]["content"], 
-                    previous_acts, screenplay_type, genre, language
-                )
-        
-        # Script doctor reviews
-        if role == "script_doctor":
-            act_mapping = {6: "Act 1", 8: "Act 2A", 10: "Act 2B"}
-            if stage_idx in act_mapping:
-                act = act_mapping[stage_idx]
-                act_content = stages[stage_idx-1]["content"]
-                return self.create_script_doctor_prompt(act_content, act, genre, language)
-        
-        # Final reviewer
-        if role == "final_reviewer":
-            complete_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
-            return self.create_final_reviewer_prompt(
-                complete_screenplay, screenplay_type, genre, language
-            )
-        
-        return ""
+    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
 
-    def _get_previous_acts(self, stages: List[Dict], current_idx: int) -> str:
-        """Get previous acts content"""
-        previous = []
-        act_indices = {5: [], 7: [5], 9: [5, 7], 11: [5, 7, 9]}
-        
-        if current_idx in act_indices:
-            for idx in act_indices[current_idx]:
-                if idx < len(stages) and stages[idx]["content"]:
-                    previous.append(stages[idx]["content"])
-        
-        return "\n\n---\n\n".join(previous) if previous else ""
+    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,
+                       age=30,  # Default age for supporting characters
+                       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
+
+    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"""
-        # Extract title and logline
-        title_match = re.search(r'(?:TITLE|제목):\s*(.+)', content)
-        logline_match = re.search(r'(?:LOGLINE|로그라인):\s*(.+)', content)
-        
-        if title_match:
-            self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
-        if logline_match:
-            self.screenplay_tracker.screenplay_bible.logline = logline_match.group(1).strip()
-        
-        # Save to database
-        ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
-                                               self.screenplay_tracker.screenplay_bible)
+       """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"""