Update app.py

app.py

@@ -1603,4 +1603,1298 @@ Provide specific solutions for each issue."""
                                             yield buffer
                                             buffer = ""
                                             time.sleep(0.01)
-                                            
+except Exception as e:
+                    logger.error(f"Error processing line {line_count}: {str(e)}")
+                    logger.debug(f"Problematic line: {line_str[:100] if 'line_str' in locals() else 'N/A'}")
+                    continue
+            
+            # Yield any remaining buffer content
+            if buffer:
+                yield buffer
+            
+            # Check if we got any content
+            if line_count == 0:
+                logger.error("No lines received from API")
+                yield "❌ No response from API"
+                
+        except requests.exceptions.Timeout:
+            logger.error("API request timed out")
+            yield "❌ Request timed out. Please try again."
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"Connection error: {e}")
+            yield "❌ Connection error. Please check your internet connection."
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request error: {type(e).__name__}: {str(e)}")
+            yield f"❌ Network error: {str(e)}"
+        except Exception as e:
+            logger.error(f"Unexpected error in streaming: {type(e).__name__}: {str(e)}")
+            import traceback
+            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"""
+        
+        base_prompts = {
+            "Korean": {
+                "producer": """당신은 20년 경력의 할리우드 프로듀서입니다.
+상업적 성공과 예술적 가치를 모두 추구합니다.
+시장 트렌드와 관객 심리를 정확히 파악합니다.
+실현 가능하고 매력적인 프로젝트를 개발합니다.""",
+                
+                "story_developer": """당신은 수상 경력이 있는 스토리 개발자입니다.
+감정적으로 공감가고 구조적으로 탄탄한 이야기를 만듭니다.
+캐릭터의 내적 여정과 외적 플롯을 조화롭게 엮습니다.
+보편적 주제를 독특한 방식으로 탐구합니다.""",
+                
+                "character_designer": """당신은 심리학을 공부한 캐릭터 디자이너입니다.
+진짜 같은 인물들을 창조하는 전문가입니다.
+각 캐릭터에게 고유한 목소리와 관점을 부여합니다.
+복잡하고 모순적인 인간성을 포착합니다.""",
+                
+                "scene_planner": """당신은 정밀한 씬 구성의 대가입니다.
+각 씬이 스토리와 캐릭터를 전진시키도록 설계합니다.
+리듬과 페이싱을 완벽하게 조절합니다.
+시각적 스토리텔링을 극대화합니다.""",
+                
+                "screenwriter": """당신은 다작의 시나리오 작가입니다.
+'보여주기'의 대가이며 서브텍스트를 능숙하게 다룹니다.
+생생하고 자연스러운 대화를 쓰는 전문가입니다.
+제작 현실을 고려하면서도 창의적인 해결책을 찾습니다.""",
+                
+                "script_doctor": """당신은 까다로운 스크립트 닥터입니다.
+작은 디테일도 놓치지 않는 완벽주의자입니다.
+스토리의 잠재력을 최대한 끌어냅니다.
+건설적이고 구체적인 개선안을 제시합니다.""",
+                
+                "critic_structure": """당신은 구조 분석 전문가입니다.
+스토리의 뼈대와 근육을 꿰뚫어 봅니다.
+논리적 허점과 감정적 공백을 찾아냅니다.
+더 나은 구조를 위한 구체적 제안을 합니다.""",
+                
+                "final_reviewer": """당신은 업계 베테랑 최종 리뷰어입니다.
+상업성과 예술성을 균형있게 평가합니다.
+제작사, 배우, 관객 모든 관점을 고려합니다.
+냉정하지만 격려하는 피드백을 제공합니다."""
+            },
+            "English": {
+                "producer": """You are a Hollywood producer with 20 years experience.
+You pursue both commercial success and artistic value.
+You accurately grasp market trends and audience psychology.
+You develop feasible and attractive projects.""",
+                
+                "story_developer": """You are an award-winning story developer.
+You create emotionally resonant and structurally sound stories.
+You harmoniously weave internal journeys with external plots.
+You explore universal themes in unique ways.""",
+                
+                "character_designer": """You are a character designer who studied psychology.
+You're an expert at creating lifelike characters.
+You give each character a unique voice and perspective.
+You capture complex and contradictory humanity.""",
+                
+                "scene_planner": """You are a master of precise scene construction.
+You design each scene to advance story and character.
+You perfectly control rhythm and pacing.
+You maximize visual storytelling.""",
+                
+                "screenwriter": """You are a prolific screenwriter.
+You're a master of 'showing' and skilled with subtext.
+You're an expert at writing vivid, natural dialogue.
+You find creative solutions while considering production reality.""",
+                
+                "script_doctor": """You are a demanding script doctor.
+You're a perfectionist who misses no small detail.
+You maximize the story's potential.
+You provide constructive and specific improvements.""",
+                
+                "critic_structure": """You are a structure analysis expert.
+You see through the story's skeleton and muscles.
+You find logical gaps and emotional voids.
+You make specific suggestions for better structure.""",
+                
+                "final_reviewer": """You are an industry veteran final reviewer.
+You evaluate commercial and artistic value in balance.
+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
+
+            # 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
+
+        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 _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 _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
+        """Parse character profile from content"""
+        # Debug logging
+        logger.debug(f"Parsing character profile for role: {role}")
+        logger.debug(f"Content preview: {content[:200]}...")
+        
+        # Extract name first - handle various formats
+        name = f"Character_{role}"  # default
+        name_patterns = [
+            r'(?:이름|Name)[:\s]*([^,\n]+?)(?:\s*\([^)]+\))?\s*',
+            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*',
+            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*'
+        ]
+        
+        for pattern in name_patterns:
+            name_match = re.search(pattern, content, re.IGNORECASE | re.MULTILINE)
+            if name_match:
+                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)
+                if extracted_name and len(extracted_name) > 1:
+                    name = extracted_name
+                    break
+        
+        # Helper function to extract clean fields
+        def extract_clean_field(patterns):
+            if isinstance(patterns, str):
+                patterns = [patterns]
+            
+            for pattern in patterns:
+                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, re.IGNORECASE | re.DOTALL)
+                if match:
+                    value = match.group(1).strip()
+                    # Clean up the value
+                    value = re.sub(r'^[-*•:\s]+', '', value)
+                    value = re.sub(r'[*]+', '', value)
+                    value = re.sub(r'\s+', ' ', value)
+                    if value:
+                        return value
+            return ""
+        
+        # Extract all fields
+        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_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
+
+    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
+
+    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}")
+
+
+
+
+
+    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_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
+        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)
+
+    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"""
+    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...")
+   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
+   )