Update app.py

app.py

@@ -732,16 +732,17 @@ class NovelDatabase:
             
             char_latest_states = {}
             for row in cursor.fetchall():
-                char_name = row['character_name']
-                if char_name not in char_latest_states or row['chapter'] > char_latest_states[char_name].last_seen_chapter:
+                row_dict = dict(row)  # Convert Row to dict
+                char_name = row_dict['character_name']
+                if char_name not in char_latest_states or row_dict['chapter'] > char_latest_states[char_name].last_seen_chapter:
                     char_state = CharacterState(
                         name=char_name,
-                        alive=bool(row['is_alive']),
-                        location=row['location'] or "",
-                        injuries=json.loads(row['injuries']) if row['injuries'] else [],
-                        emotional_state=row['emotional_state'] or "",
-                        relationships=json.loads(row['relationships']) if row['relationships'] else {},
-                        last_seen_chapter=row['chapter']
+                        alive=bool(row_dict['is_alive']),
+                        location=row_dict['location'] or "",
+                        injuries=json.loads(row_dict['injuries']) if row_dict['injuries'] else [],
+                        emotional_state=row_dict['emotional_state'] or "",
+                        relationships=json.loads(row_dict['relationships']) if row_dict['relationships'] else {},
+                        last_seen_chapter=row_dict['chapter']
                     )
                     char_latest_states[char_name] = char_state
             
@@ -755,12 +756,13 @@ class NovelDatabase:
             ''', (session_id,))
             
             for row in cursor.fetchall():
+                row_dict = dict(row)  # Convert Row to dict
                 plot_point = PlotPoint(
-                    chapter=row['chapter'],
-                    event_type=row['event_type'],
-                    description=row['description'],
-                    characters_involved=json.loads(row['characters_involved']) if row['characters_involved'] else [],
-                    impact_level=row['impact_level']
+                    chapter=row_dict['chapter'],
+                    event_type=row_dict['event_type'],
+                    description=row_dict['description'],
+                    characters_involved=json.loads(row_dict['characters_involved']) if row_dict['characters_involved'] else [],
+                    impact_level=row_dict['impact_level']
                 )
                 tracker.plot_points.append(plot_point)
         
@@ -980,6 +982,13 @@ class NovelDatabase:
             return datetime.fromisoformat(datetime_str)
         except:
             return datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
+    
+    @staticmethod
+    def row_to_dict(row):
+        """Convert sqlite3.Row to dictionary"""
+        if row is None:
+            return None
+        return dict(row) if hasattr(row, 'keys') else row
 
 
 class NovelWritingSystem:
@@ -2187,9 +2196,10 @@ Five years ago, her younger sister Seojin had died in a car accident. The memory
                 self.current_session_id = session_id
                 session = NovelDatabase.get_session(session_id)
                 if session:
-                    query = session['user_query']
-                    language = session['language']
-                    resume_from_stage = session['current_stage'] + 1
+                    session_dict = dict(session)  # Convert Row to dict
+                    query = session_dict['user_query']
+                    language = session_dict['language']
+                    resume_from_stage = session_dict['current_stage'] + 1
                     # Load existing state tracker
                     self.state_tracker = NovelDatabase.load_session_state_tracker(session_id)
                     logger.info(f"Resuming session {session_id} from stage {resume_from_stage}")
@@ -2213,11 +2223,13 @@ Five years ago, her younger sister Seojin had died in a car accident. The memory
             if resume_from_stage > 0:
                 existing_stages = NovelDatabase.get_stages(self.current_session_id)
                 for stage_data in existing_stages:
+                    # Convert sqlite3.Row to dict
+                    stage_dict = dict(stage_data)
                     stages.append({
-                        "name": stage_data['stage_name'],
-                        "status": stage_data['status'],
-                        "content": stage_data['content'] or "",
-                        "quality_score": stage_data.get('quality_score', 0.0)
+                        "name": stage_dict['stage_name'],
+                        "status": stage_dict['status'],
+                        "content": stage_dict['content'] or "",
+                        "quality_score": stage_dict.get('quality_score', 0.0)
                     })
             
             # Define all stages for 10 writers
@@ -2601,11 +2613,12 @@ def get_active_sessions(language: str) -> List[Tuple[str, str]]:
         
         choices = []
         for session in sessions:
-            created = NovelDatabase.parse_datetime(session['created_at'])
+            session_dict = dict(session)  # Convert Row to dict
+            created = NovelDatabase.parse_datetime(session_dict['created_at'])
             date_str = created.strftime("%Y-%m-%d %H:%M")
-            query_preview = session['user_query'][:50] + "..." if len(session['user_query']) > 50 else session['user_query']
-            label = f"[{date_str}] {query_preview} (Stage {session['current_stage']})"
-            choices.append((label, session['session_id']))
+            query_preview = session_dict['user_query'][:50] + "..." if len(session_dict['user_query']) > 50 else session_dict['user_query']
+            label = f"[{date_str}] {query_preview} (Stage {session_dict['current_stage']})"
+            choices.append((label, session_dict['session_id']))
         
         return choices
     except Exception as e:
@@ -2631,11 +2644,12 @@ def auto_recover_session(language: str) -> Tuple[str, str]:
     try:
         latest_session = NovelDatabase.get_latest_active_session()
         if latest_session:
+            session_dict = dict(latest_session)  # Convert Row to dict
             if language == "Korean":
-                message = f"✅ 자동 복구: '{latest_session['user_query'][:30]}...' (Stage {latest_session['current_stage']})"
+                message = f"✅ 자동 복구: '{session_dict['user_query'][:30]}...' (Stage {session_dict['current_stage']})"
             else:
-                message = f"✅ Auto recovered: '{latest_session['user_query'][:30]}...' (Stage {latest_session['current_stage']})"
-            return latest_session['session_id'], message
+                message = f"✅ Auto recovered: '{session_dict['user_query'][:30]}...' (Stage {session_dict['current_stage']})"
+            return session_dict['session_id'], message
         else:
             return None, ""
     except Exception as e:
@@ -2691,8 +2705,11 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         logger.error(f"Session not found: {session_id}")
         return None
     
+    # Convert sqlite3.Row to dict
+    session_dict = dict(session) if session else {}
+    
     # 세션의 실제 언어 사용
-    actual_language = session['language']
+    actual_language = session_dict['language']
     logger.info(f"Using session language: {actual_language}")
     
     # DB에서 모든 스테이지 가져오기
@@ -2700,13 +2717,13 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
     logger.info(f"Found {len(stages)} stages in database")
     
     # 품질 점수 가져오기
-    quality_scores = json.loads(session.get('quality_scores', '{}')) if session.get('quality_scores') else {}
+    quality_scores = json.loads(session_dict.get('quality_scores', '{}')) if session_dict.get('quality_scores') else {}
     
     # 테스트 모드 감지
     is_test_mode = False
-    has_writer10 = any(stage['role'] == 'writer10' for stage in stages if 'role' in stage.keys())
-    has_writer1 = any(stage['role'] == 'writer1' for stage in stages if 'role' in stage.keys())
-    has_writer3 = any(stage['role'] == 'writer3' for stage in stages if 'role' in stage.keys())
+    has_writer10 = any(dict(stage).get('role') == 'writer10' for stage in stages)
+    has_writer1 = any(dict(stage).get('role') == 'writer1' for stage in stages)
+    has_writer3 = any(dict(stage).get('role') == 'writer3' for stage in stages)
     
     if has_writer10 and has_writer1 and not has_writer3:
         is_test_mode = True
@@ -2734,7 +2751,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         
         theme_para = doc.add_paragraph()
         theme_label = '주제: ' if actual_language == 'Korean' else 'Theme: '
-        theme_run = theme_para.add_run(f'{theme_label}{session["user_query"]}')
+        theme_run = theme_para.add_run(f'{theme_label}{session_dict["user_query"]}')
         theme_run.font.size = Pt(12)
         theme_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
         
@@ -2770,9 +2787,10 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         if is_test_mode:
             # 테스트 모드: writer1 revision + writer10 내용 처리
             for stage in stages:
-                role = stage['role'] if 'role' in stage.keys() else None
-                stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
-                content = stage['content'] if 'content' in stage.keys() else ''
+                stage_dict = dict(stage)  # Convert Row to dict
+                role = stage_dict.get('role')
+                stage_name = stage_dict.get('stage_name', '')
+                content = stage_dict.get('content', '')
                 
                 # Writer 1 수정본
                 if role == 'writer1' and stage_name and ('Revision' in stage_name or '수정본' in stage_name):
@@ -2781,13 +2799,13 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                     content = content.strip()
                     
                     if content:
-                        word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                        word_count = stage_dict.get('word_count', len(content.split()))
                         total_words += word_count
                         writer_contents.append({
                             'writer_num': 1,
                             'content': content,
                             'word_count': word_count,
-                            'quality_score': stage.get('quality_score', 0)
+                            'quality_score': stage_dict.get('quality_score', 0)
                         })
                         writer_count = 1
                         logger.info(f"Added writer 1 (Chapter 1): {word_count} words")
@@ -2811,7 +2829,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                                     'writer_num': chapter_num,
                                     'content': chapter_content,
                                     'word_count': word_count,
-                                    'quality_score': stage.get('quality_score', 0)
+                                    'quality_score': stage_dict.get('quality_score', 0)
                                 })
                                 writer_count = max(writer_count, chapter_num)
                                 logger.info(f"Added Chapter {chapter_num}: {word_count} words")
@@ -2820,9 +2838,10 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
             logger.info("[NORMAL MODE] Processing all writer revisions...")
             
             for stage in stages:
-                role = stage['role'] if 'role' in stage.keys() else None
-                stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
-                content = stage['content'] if 'content' in stage.keys() else ''
+                stage_dict = dict(stage)  # Convert Row to dict
+                role = stage_dict.get('role')
+                stage_name = stage_dict.get('stage_name', '')
+                content = stage_dict.get('content', '')
                 
                 # 작가 수정본 찾기
                 is_writer = role and role.startswith('writer')
@@ -2841,13 +2860,13 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                     content = content.strip()
                     
                     if content:
-                        word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                        word_count = stage_dict.get('word_count', len(content.split()))
                         total_words += word_count
                         writer_contents.append({
                             'writer_num': writer_num,
                             'content': content,
                             'word_count': word_count,
-                            'quality_score': stage.get('quality_score', 0)
+                            'quality_score': stage_dict.get('quality_score', 0)
                         })
                         writer_count += 1
                         logger.info(f"Added writer {writer_num}: {word_count} words")
@@ -2967,7 +2986,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         
         # Save
         temp_dir = tempfile.gettempdir()
-        safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
+        safe_filename = re.sub(r'[^\w\s-]', '', session_dict['user_query'][:30]).strip()
         mode_suffix = "_TestMode" if is_test_mode else "_Complete"
         filename = f"Novel{mode_suffix}_{safe_filename}_{timestamp}.docx"
         filepath = os.path.join(temp_dir, filename)
@@ -2978,7 +2997,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
     else:
         # TXT format
         temp_dir = tempfile.gettempdir()
-        safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
+        safe_filename = re.sub(r'[^\w\s-]', '', session_dict['user_query'][:30]).strip()
         mode_suffix = "_TestMode" if is_test_mode else "_Complete"
         filename = f"Novel{mode_suffix}_{safe_filename}_{timestamp}.txt"
         filepath = os.path.join(temp_dir, filename)
@@ -2992,14 +3011,14 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
             f.write("="*60 + "\n")
             
             if actual_language == 'Korean':
-                f.write(f"주제: {session['user_query']}\n")
+                f.write(f"주제: {session_dict['user_query']}\n")
                 f.write(f"언어: 한국어\n")
                 f.write(f"생성일: {datetime.now()}\n")
                 f.write(f"모드: {'테스트 모드 (실제 작성된 챕터)' if is_test_mode else '전체 모드 (10개 챕터)'}\n")
                 if quality_scores:
                     f.write(f"품질 점수: {quality_scores.get('overall', 0):.1f}/10\n")
             else:
-                f.write(f"Theme: {session['user_query']}\n")
+                f.write(f"Theme: {session_dict['user_query']}\n")
                 f.write(f"Language: English\n")
                 f.write(f"Created: {datetime.now()}\n")
                 f.write(f"Mode: {'Test Mode (Actual chapters)' if is_test_mode else 'Full Mode (10 chapters)'}\n")
@@ -3016,9 +3035,10 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
             if is_test_mode:
                 # 테스트 모드 처리 (DOCX와 동일)
                 for stage in stages:
-                    role = stage['role'] if 'role' in stage.keys() else None
-                    stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
-                    content = stage['content'] if 'content' in stage.keys() else ''
+                    stage_dict = dict(stage)  # Convert Row to dict
+                    role = stage_dict.get('role')
+                    stage_name = stage_dict.get('stage_name', '')
+                    content = stage_dict.get('content', '')
                     
                     if role == 'writer1' and stage_name and ('Revision' in stage_name or '수정본' in stage_name):
                         content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
@@ -3026,7 +3046,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                         content = content.strip()
                         
                         if content:
-                            word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                            word_count = stage_dict.get('word_count', len(content.split()))
                             total_words += word_count
                             writer_count = 1
                             
@@ -3037,8 +3057,8 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                             f.write(f"{chapter_title}\n")
                             word_count_label = f"단어 수: {word_count:,}" if actual_language == 'Korean' else f"Word Count: {word_count:,}"
                             f.write(f"{word_count_label}\n")
-                            if stage.get('quality_score', 0) > 0:
-                                quality_label = f"품질: {stage['quality_score']:.1f}/10" if actual_language == 'Korean' else f"Quality: {stage['quality_score']:.1f}/10"
+                            if stage_dict.get('quality_score', 0) > 0:
+                                quality_label = f"품질: {stage_dict['quality_score']:.1f}/10" if actual_language == 'Korean' else f"Quality: {stage_dict['quality_score']:.1f}/10"
                                 f.write(f"{quality_label}\n")
                             f.write(f"{'='*40}\n\n")
                             f.write(content)
@@ -3070,9 +3090,10 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
             else:
                 # 일반 모드
                 for stage in stages:
-                    role = stage['role'] if 'role' in stage.keys() else None
-                    stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
-                    content = stage['content'] if 'content' in stage.keys() else ''
+                    stage_dict = dict(stage)  # Convert Row to dict
+                    role = stage_dict.get('role')
+                    stage_name = stage_dict.get('stage_name', '')
+                    content = stage_dict.get('content', '')
                     
                     is_writer = role and role.startswith('writer')
                     is_revision = stage_name and ('Revision' in stage_name or '수정본' in stage_name)
@@ -3088,7 +3109,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                         content = content.strip()
                         
                         if content:
-                            word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                            word_count = stage_dict.get('word_count', len(content.split()))
                             total_words += word_count
                             writer_count += 1
                             
@@ -3099,8 +3120,8 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
                             f.write(f"{chapter_title}\n")
                             word_count_label = f"단어 수: {word_count:,}" if actual_language == 'Korean' else f"Word Count: {word_count:,}"
                             f.write(f"{word_count_label}\n")
-                            if stage.get('quality_score', 0) > 0:
-                                quality_label = f"품질: {stage['quality_score']:.1f}/10" if actual_language == 'Korean' else f"Quality: {stage['quality_score']:.1f}/10"
+                            if stage_dict.get('quality_score', 0) > 0:
+                                quality_label = f"품질: {stage_dict['quality_score']:.1f}/10" if actual_language == 'Korean' else f"Quality: {stage_dict['quality_score']:.1f}/10"
                                 f.write(f"{quality_label}\n")
                             f.write(f"{'='*40}\n\n")
                             f.write(content)