Update app.py

app.py

@@ -1345,28 +1345,6 @@ def create_interface():
                 padding-bottom: 10px;
             }
             
-            .panel-content {
-                display: grid;
-                grid-template-columns: 1fr 1fr;
-                gap: 20px;
-            }
-            
-            .panel-text {
-                padding: 15px;
-                background: #f9f9f9;
-                border-radius: 8px;
-            }
-            
-            .panel-image {
-                min-height: 300px;
-                background: #f0f0f0;
-                border-radius: 8px;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-                position: relative;
-            }
-            
             .episode-structure {
                 background: #f5f5f5;
                 padding: 15px;
@@ -1375,17 +1353,6 @@ def create_interface():
                 max-height: 500px;
                 overflow-y: auto;
             }
-            
-            .edit-field {
-                margin: 10px 0;
-            }
-            
-            .edit-label {
-                font-weight: bold;
-                color: #333;
-                margin-bottom: 5px;
-                display: block;
-            }
         </style>
         
         <div class="main-header">
@@ -1395,7 +1362,7 @@ def create_interface():
         </div>
         """)
         
-        # State
+        # State variables
         current_session_id = gr.State(None)
         planning_state = gr.State("")
         storyboard_state = gr.State("")
@@ -1451,7 +1418,7 @@ def create_interface():
                     value="장르를 선택하고 콘셉트를 입력하세요"
                 )
             
-            # Planning output - Plain text
+            # Planning output
             gr.Markdown("### 📖 웹툰 기획안 (40화 전체 구성)")
             planning_display = gr.Textbox(
                 label="기획안",
@@ -1461,10 +1428,8 @@ def create_interface():
                 value="기획안이 여기에 표시됩니다 (40화 전체 구성 포함)"
             )
             
-            # Character profiles display
             character_display = gr.HTML(label="캐릭터 프로필")
             
-            # Download section
             with gr.Row():
                 download_planning_btn = gr.Button("📥 기획안 다운로드 (40화 구성)", variant="secondary")
             
@@ -1473,103 +1438,40 @@ def create_interface():
         with gr.Tab("🎬 1화 스토리보드 (30패널)"):
             gr.Markdown("""
             ### 📋 1화 스토리보드 - 30개 패널
-            각 패널의 텍스트를 직접 편집할 수 있습니다. 편집 후 '변경사항 저장' 버튼을 클릭하세요.
+            각 패널의 텍스트를 편집할 수 있습니다. 편집 후 '적용' 버튼을 클릭하세요.
             """)
             
-            # Controls
+            # Control buttons
             with gr.Row():
-                save_edits_btn = gr.Button("💾 변경사항 저장", variant="secondary")
-                generate_all_images_btn = gr.Button("🎨 모든 패널 이미지 생성 (30개)", variant="primary", size="lg")
+                apply_edits_btn = gr.Button("✅ 편집 내용 적용", variant="secondary")
+                generate_all_images_btn = gr.Button("🎨 모든 패널 이미지 생성", variant="primary", size="lg")
                 download_storyboard_btn = gr.Button("📥 스토리보드 다운로드", variant="secondary")
                 clear_images_btn = gr.Button("🗑️ 이미지 초기화", variant="secondary")
             
             storyboard_download_file = gr.File(visible=False)
+            generation_progress = gr.Textbox(label="진행 상황", interactive=False, visible=False)
             
-            # Progress indicator
-            generation_progress = gr.Textbox(label="생성 진행 상황", interactive=False, visible=False)
-            edit_status = gr.Textbox(label="편집 상태", interactive=False, visible=False)
+            # Editable storyboard display
+            storyboard_editor = gr.Textbox(
+                label="스토리보드 편집기",
+                lines=30,
+                max_lines=50,
+                interactive=True,
+                placeholder="스토리보드가 생성되면 여기에 표시됩니다. 자유롭게 편집하세요."
+            )
             
-            # Create panels with editable fields
-            panel_components = []
-            with gr.Column():
-                for i in range(30):
-                    with gr.Group(visible=False) as panel_group:
-                        gr.Markdown(f"### 🎬 패널 {i+1}")
-                        
-                        with gr.Row():
-                            with gr.Column():
-                                # Editable text fields
-                                shot_input = gr.Textbox(
-                                    label="샷 타입",
-                                    lines=1,
-                                    interactive=True,
-                                    elem_id=f"shot_{i+1}"
-                                )
-                                
-                                prompt_input = gr.Textbox(
-                                    label="이미지 프롬프트 (한글)",
-                                    lines=3,
-                                    interactive=True,
-                                    elem_id=f"prompt_{i+1}"
-                                )
-                                
-                                prompt_en_display = gr.Textbox(
-                                    label="영어 번역 (자동)",
-                                    lines=3,
-                                    interactive=False,
-                                    elem_id=f"prompt_en_{i+1}"
-                                )
-                                
-                                dialogue_input = gr.Textbox(
-                                    label="대사",
-                                    lines=2,
-                                    interactive=True,
-                                    elem_id=f"dialogue_{i+1}"
-                                )
-                                
-                                narration_input = gr.Textbox(
-                                    label="나레이션",
-                                    lines=2,
-                                    interactive=True,
-                                    elem_id=f"narration_{i+1}"
-                                )
-                                
-                                effects_input = gr.Textbox(
-                                    label="효과음",
-                                    lines=1,
-                                    interactive=True,
-                                    elem_id=f"effects_{i+1}"
-                                )
-                            
-                            with gr.Column():
-                                # Image display
-                                panel_image = gr.Image(
-                                    label=f"패널 {i+1} 이미지",
-                                    elem_id=f"image_{i+1}",
-                                    type="pil"
-                                )
-                                
-                                # Individual regeneration button
-                                regenerate_btn = gr.Button(
-                                    f"🔄 패널 {i+1} 이미지 재생성",
-                                    variant="secondary",
-                                    elem_id=f"regen_{i+1}"
-                                )
-                        
-                        panel_components.append({
-                            'group': panel_group,
-                            'shot': shot_input,
-                            'prompt': prompt_input,
-                            'prompt_en': prompt_en_display,
-                            'dialogue': dialogue_input,
-                            'narration': narration_input,
-                            'effects': effects_input,
-                            'image': panel_image,
-                            'regenerate': regenerate_btn,
-                            'panel_num': i+1
-                        })
-
-        # Event handlers
+            # Panel images gallery
+            gr.Markdown("### 🖼️ 생성된 이미지")
+            images_gallery = gr.Gallery(
+                label="패널 이미지",
+                show_label=False,
+                elem_id="gallery",
+                columns=5,
+                rows=6,
+                height="auto"
+            )
+
+        # Helper functions
         def process_query(query, genre, language, session_id):
             system = WebtoonSystem()
             planning = ""
@@ -1583,7 +1485,6 @@ def create_interface():
                 yield planning, storyboard, status, new_session_id, character_profiles, system
         
         def format_character_profiles(profiles: Dict[str, CharacterProfile]) -> str:
-            """Format character profiles for display"""
             if not profiles:
                 return ""
             
@@ -1599,124 +1500,73 @@ def create_interface():
                 """
             return html
         
-        def update_panel_components(storyboard_content, session_id, character_profiles):
-            """Update panel components with parsed storyboard data"""
-            if not storyboard_content:
-                return [gr.update(visible=False) for _ in range(30*9)], []
-            
-            if "패널" not in storyboard_content and "Panel" not in storyboard_content:
-                return [gr.update(visible=False) for _ in range(30*9)], []
-            
-            panel_data = parse_storyboard_panels(storyboard_content, character_profiles)
-            updates = []
-            
-            for i in range(30):
-                if i < len(panel_data):
-                    panel = panel_data[i]
-                    # Group visibility
-                    updates.append(gr.update(visible=True))
-                    # Shot type
-                    updates.append(gr.update(value=panel.get('shot', '')))
-                    # Prompt
-                    updates.append(gr.update(value=panel.get('prompt', '')))
-                    # Prompt English
-                    updates.append(gr.update(value=panel.get('prompt_en', '')))
-                    # Dialogue
-                    updates.append(gr.update(value=panel.get('dialogue', '')))
-                    # Narration
-                    updates.append(gr.update(value=panel.get('narration', '')))
-                    # Effects
-                    updates.append(gr.update(value=panel.get('effects', '')))
-                    # Image (initially empty)
-                    updates.append(gr.update(value=None))
-                    # Regenerate button
-                    updates.append(gr.update())
-                else:
-                    # Hide unused panels
-                    updates.extend([gr.update(visible=False)] + [gr.update()] * 8)
+        def apply_edited_storyboard(edited_text, session_id, character_profiles):
+            """Parse and apply edited storyboard text"""
+            if not edited_text:
+                return [], "스토리보드가 비어있습니다."
             
-            return updates, panel_data
-        
-        def save_panel_edits(*args):
-            """Save edited panel data"""
-            # args contains all panel component values
+            # Parse the edited text back into panel data
             panel_data = []
-            num_components_per_panel = 8  # Excluding group visibility
+            lines = edited_text.split('\n')
+            current_panel = None
             
-            for i in range(30):
-                start_idx = i * num_components_per_panel
-                if start_idx < len(args) - 3:  # Exclude last 3 state arguments
-                    panel = {
-                        'number': i + 1,
-                        'shot': args[start_idx],
-                        'prompt': args[start_idx + 1],
-                        'prompt_en': args[start_idx + 2],
-                        'dialogue': args[start_idx + 3],
-                        'narration': args[start_idx + 4],
-                        'effects': args[start_idx + 5],
+            for line in lines:
+                if '패널' in line and any(char.isdigit() for char in line):
+                    if current_panel and current_panel.get('prompt'):
+                        panel_data.append(current_panel)
+                    
+                    numbers = re.findall(r'\d+', line)
+                    panel_num = int(numbers[0]) if numbers else len(panel_data) + 1
+                    
+                    current_panel = {
+                        'number': panel_num,
+                        'shot': '',
+                        'prompt': '',
+                        'prompt_en': '',
+                        'dialogue': '',
+                        'narration': '',
+                        'effects': '',
                         'image_url': None
                     }
-                    if panel['prompt']:  # Only add panels with content
-                        panel_data.append(panel)
-            
-            return panel_data, gr.update(visible=True, value="✅ 변경사항이 저장되었습니다")
-        
-        def generate_single_panel(panel_num, panel_data, session_id, character_profiles, webtoon_system):
-            """Generate image for a single panel"""
-            if not REPLICATE_API_TOKEN:
-                return gr.update(value=None)
-            
-            if not webtoon_system:
-                webtoon_system = WebtoonSystem()
-            
-            panel = next((p for p in panel_data if p['number'] == panel_num), None)
-            
-            if not panel or not panel.get('prompt'):
-                return gr.update(value=None)
-            
-            # Translate if needed
-            if not panel.get('prompt_en'):
-                panel['prompt_en'] = webtoon_system.translate_prompt_to_english(
-                    panel['prompt'], character_profiles
-                )
+                elif current_panel:
+                    if '샷 타입:' in line or 'Shot type:' in line.lower():
+                        current_panel['shot'] = line.split(':', 1)[1].strip() if ':' in line else ''
+                    elif '이미지 프롬프트:' in line or 'Image prompt:' in line.lower():
+                        current_panel['prompt'] = line.split(':', 1)[1].strip() if ':' in line else ''
+                    elif '대사:' in line or 'Dialogue:' in line.lower():
+                        current_panel['dialogue'] = line.split(':', 1)[1].strip() if ':' in line else ''
+                    elif '나레이션:' in line or 'Narration:' in line.lower():
+                        current_panel['narration'] = line.split(':', 1)[1].strip() if ':' in line else ''
+                    elif '효과음:' in line or 'Sound effect:' in line.lower():
+                        current_panel['effects'] = line.split(':', 1)[1].strip() if ':' in line else ''
             
-            # Generate image
-            result = webtoon_system.image_generator.generate_image(
-                panel['prompt_en'],
-                f"ep1_panel{panel_num}",
-                session_id
-            )
-            
-            if result['status'] == 'success':
-                # Load image from URL
-                import requests
-                from PIL import Image
-                from io import BytesIO
-                
-                response = requests.get(result['image_url'])
-                img = Image.open(BytesIO(response.content))
-                return gr.update(value=img)
+            if current_panel and current_panel.get('prompt'):
+                panel_data.append(current_panel)
             
-            return gr.update(value=None)
+            return panel_data[:30], f"✅ {len(panel_data)}개 패널이 적용되었습니다."
         
-        def generate_all_images(panel_data, session_id, character_profiles, webtoon_system, progress=gr.Progress()):
-            """Generate images for all panels"""
+        def generate_all_panel_images_from_editor(panel_data, session_id, character_profiles, webtoon_system, progress=gr.Progress()):
+            """Generate images for all panels from edited data"""
             if not REPLICATE_API_TOKEN:
-                return [gr.update()] * 30, gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다")
+                return [], gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다.")
+            
+            if not panel_data:
+                return [], gr.update(visible=True, value="⚠️ 패널 데이터가 없습니다.")
             
             if not webtoon_system:
                 webtoon_system = WebtoonSystem()
             
-            updates = []
+            generated_images = []
             total_panels = len(panel_data)
+            successful = 0
+            failed = 0
             
-            for i in range(30):
-                if i < total_panels:
-                    panel = panel_data[i]
-                    progress((i / total_panels), desc=f"패널 {i+1}/{total_panels} 생성 중...")
-                    
-                    if panel.get('prompt'):
-                        # Translate if needed
+            for i, panel in enumerate(panel_data):
+                progress((i / total_panels), desc=f"패널 {panel['number']}/{total_panels} 생성 중...")
+                
+                if panel.get('prompt'):
+                    try:
+                        # Translate to English if needed
                         if not panel.get('prompt_en'):
                             panel['prompt_en'] = webtoon_system.translate_prompt_to_english(
                                 panel['prompt'], character_profiles
@@ -1725,39 +1575,38 @@ def create_interface():
                         # Generate image
                         result = webtoon_system.image_generator.generate_image(
                             panel['prompt_en'],
-                            f"ep1_panel{i+1}",
+                            f"ep1_panel{panel['number']}",
                             session_id
                         )
                         
                         if result['status'] == 'success':
+                            # Download and convert image
                             import requests
                             from PIL import Image
                             from io import BytesIO
                             
                             response = requests.get(result['image_url'])
                             img = Image.open(BytesIO(response.content))
-                            updates.append(gr.update(value=img))
+                            generated_images.append((img, f"Panel {panel['number']}"))
+                            successful += 1
                         else:
-                            updates.append(gr.update(value=None))
-                    else:
-                        updates.append(gr.update(value=None))
+                            failed += 1
+                    except Exception as e:
+                        logger.error(f"Error generating panel {panel['number']}: {e}")
+                        failed += 1
                     
                     time.sleep(0.5)  # Rate limiting
-                else:
-                    updates.append(gr.update())
             
-            progress(1.0, desc="이미지 생성 완료!")
-            return updates, gr.update(visible=False)
+            progress(1.0, desc=f"완료! 성공: {successful}, 실패: {failed}")
+            return generated_images, gr.update(visible=False)
         
         def clear_all_images():
-            """Clear all images"""
-            return [gr.update(value=None) for _ in range(30)]
+            return []
         
         def handle_random_theme(genre, language):
             return generate_random_webtoon_theme(genre, language)
         
         def download_planning(session_id, planning, genre):
-            """Download planning document"""
             try:
                 title = f"{genre} 웹툰"
                 content = export_planning_to_txt(planning, genre, title)
@@ -1770,23 +1619,9 @@ def create_interface():
                 logger.error(f"Download error: {e}")
                 return None
         
-        def download_storyboard_from_panels(panel_data, genre):
-            """Download storyboard from panel data"""
+        def download_storyboard_from_editor(edited_text, genre):
             try:
-                content = f"{'=' * 50}\n"
-                content += f"{genre} 웹툰 - 1화 스토리보드\n"
-                content += f"{'=' * 50}\n\n"
-                
-                for panel in panel_data:
-                    content += f"\n패널 {panel['number']}:\n"
-                    content += f"- 샷 타입: {panel.get('shot', '')}\n"
-                    content += f"- 이미지 프롬프트: {panel.get('prompt', '')}\n"
-                    if panel.get('dialogue'):
-                        content += f"- 대사: {panel.get('dialogue')}\n"
-                    if panel.get('narration'):
-                        content += f"- 나레이션: {panel.get('narration')}\n"
-                    if panel.get('effects'):
-                        content += f"- 효과음: {panel.get('effects')}\n"
+                content = export_storyboard_to_txt(edited_text, genre, 1)
                 
                 with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', 
                                                suffix='_storyboard.txt', delete=False) as f:
@@ -1797,8 +1632,6 @@ def create_interface():
                 return None
 
         # Connect events
-        
-        # Main submission
         submit_btn.click(
             fn=process_query,
             inputs=[query_input, genre_select, language_select, current_session_id],
@@ -1812,36 +1645,19 @@ def create_interface():
             inputs=[character_profiles_state],
             outputs=[character_display]
         ).then(
-            fn=update_panel_components,
-            inputs=[storyboard_state, current_session_id, character_profiles_state],
-            outputs=[
-                # All panel component updates
-                *[comp for panel in panel_components for comp in [
-                    panel['group'], panel['shot'], panel['prompt'], panel['prompt_en'],
-                    panel['dialogue'], panel['narration'], panel['effects'], 
-                    panel['image'], panel['regenerate']
-                ]],
-                panel_data_state
-            ]
+            fn=lambda x: x,
+            inputs=[storyboard_state],
+            outputs=[storyboard_editor]
         )
         
-        # Save edits
-        all_text_inputs = []
-        for panel in panel_components:
-            all_text_inputs.extend([
-                panel['shot'], panel['prompt'], panel['prompt_en'],
-                panel['dialogue'], panel['narration'], panel['effects']
-            ])
-        
-        save_edits_btn.click(
-            fn=save_panel_edits,
-            inputs=all_text_inputs + [panel_data_state, current_session_id, character_profiles_state],
-            outputs=[panel_data_state, edit_status]
+        # Apply edits button
+        apply_edits_btn.click(
+            fn=apply_edited_storyboard,
+            inputs=[storyboard_editor, current_session_id, character_profiles_state],
+            outputs=[panel_data_state, generation_progress]
         ).then(
-            fn=lambda: gr.update(visible=False),
-            inputs=[],
-            outputs=[edit_status],
-            _js="() => setTimeout(() => {}, 3000)"
+            fn=lambda: gr.update(visible=True, value="편집 내용이 적용되었습니다."),
+            outputs=[generation_progress]
         )
         
         # Generate all images
@@ -1849,24 +1665,15 @@ def create_interface():
             fn=lambda: gr.update(visible=True, value="이미지 생성 시작..."),
             outputs=[generation_progress]
         ).then(
-            fn=generate_all_images,
+            fn=generate_all_panel_images_from_editor,
             inputs=[panel_data_state, current_session_id, character_profiles_state, webtoon_system],
-            outputs=[*[panel['image'] for panel in panel_components], generation_progress]
+            outputs=[images_gallery, generation_progress]
         )
         
-        # Individual panel regeneration
-        for panel in panel_components:
-            panel['regenerate'].click(
-                fn=generate_single_panel,
-                inputs=[gr.State(panel['panel_num']), panel_data_state, current_session_id, 
-                       character_profiles_state, webtoon_system],
-                outputs=[panel['image']]
-            )
-        
         # Clear images
         clear_images_btn.click(
             fn=clear_all_images,
-            outputs=[panel['image'] for panel in panel_components]
+            outputs=[images_gallery]
         )
         
         # Random theme
@@ -1888,8 +1695,8 @@ def create_interface():
         )
         
         download_storyboard_btn.click(
-            fn=download_storyboard_from_panels,
-            inputs=[panel_data_state, genre_select],
+            fn=download_storyboard_from_editor,
+            inputs=[storyboard_editor, genre_select],
             outputs=[storyboard_download_file]
         ).then(
             fn=lambda x: gr.update(visible=True) if x else gr.update(visible=False),