Update app.py

app.py

@@ -3,8 +3,10 @@ import os
 #os.environ["PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS"] = "1"
 # --------------------------------------------------------------------------
 
-from flask import Flask, render_template, jsonify, request
-from flask_socketio import SocketIO
+from flask import Flask, render_template, jsonify, request, Response
+from flask_socketio import SocketIO, emit
+import uuid
+
 import threading
 import sqlite3
 import gc
@@ -58,6 +60,9 @@ region_paths = {
 # --- 프롬프트 ---
 lexi_prompts = leximind_prompts.PromptLibrary()
 
+# 세션별 요청 추적을 위한 딕셔너리
+active_sessions = {}
+
 # --- RAG 객체 ---
 region_rag_objects = {}
 
@@ -124,33 +129,187 @@ def load_rag_objects():
 # --- 웹 ---
 @app.route('/')
 def index():
-    return render_template('chat.html')
+    return render_template('chat_v02.html')
 
-# --- 메시지 ---
-@app.route('/get_message', methods=['POST'])
-def get_message():
-    global Filtered_search, filters
-    data = request.get_json()
-    query = data.get('query', '').strip()
-    regions = data.get('regions', [])
-    selected_regulations = data.get('selectedRegulations', [])
-
-    logger.info(f"Query: {query}")
-
-    filters = {"regulation_part": []}
-    Filtered_search = bool(selected_regulations)
-    if selected_regulations:
-        for reg in selected_regulations:
-            title = reg.get('title', '')
-            if title:
-                filters["regulation_part"].append(title)
-
-    Rag_Results = search_DB_from_multiple_regions(query, regions, region_rag_objects)
-    AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
+# 전역 변수에 기본값 추가
+Search_each_all_mode = True  # 기본값을 클라이언트에서 제어 가능
+
+@socketio.on('search_query')
+def handle_search_query(data):
+    global Filtered_search
+    global filters
+    global Search_each_all_mode
+
+    # 세션 ID 생성
+    session_id = str(uuid.uuid4())
+    active_sessions[session_id] = True
+    
+    # 클라이언트에 session_id 전달
+    emit('search_started', {'session_id': session_id})
     
-    logger.info(f"Answer: {AImessage}")
+    try:
+        # 클라이언트에서 전송된 검색 모드 사용
+        Search_each_all_mode = data.get('searchEachMode', True)
+
+        query = data.get('query', '')
+        regions = data.get('regions', [])
+        selected_regulations = data.get('selectedRegulations', [])
+        
+        emit('search_status', {'status': 'processing', 'message': '검색 요청을 처리하는 중입니다...'})
+        
+        logger.info(f"선택된 지역 : {regions}")
+        logger.info(f"선택된 법규 : {selected_regulations}")
+        if Search_each_all_mode:
+            logger.info(f"검색 모드 : 각각 검색")
+        else:
+            logger.info(f"검색 모드 : 통합 검색")
+
+        # 법규 타입별로 필터 구분
+        filters = {
+            "regulation_part": [],
+            "regulation_section": [], 
+            "chapter_section": [],
+            "jo": []
+        }
+
+        # 번역 진행 상황 알림
+        emit('search_status', {'status': 'translating', 'message': '질문을 번역하는 중입니다...'})
+        
+        if session_id not in active_sessions:
+            emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
+            emit('search_status', {'status': 'processing', 'message': 'Ready to search'})
+            return
+
+        Translated_query = Gemma3_AI_Translate(query)
+        emit('search_status', {'status': 'translated', 'message': f'번역 완료: {Translated_query}'})
+        logger.info(f"Query: Original query : {query}")
+        logger.info(f"Query: Translated_query : {Translated_query}")
+        
+        if selected_regulations:
+            Filtered_search = True
+            cont_selected_num = 0
+
+            # 파일로 저장
+            output_path = os.path.join(current_dir, "merged_ai_messages.txt")
+            
+            if os.path.exists(output_path):
+                os.remove(output_path)
+                print(f"기존 파일 삭제 완료: {output_path}")
+
+            if Search_each_all_mode:
+                # 각각 검색 모드
+                emit('search_status', {'status': 'searching', 'message': f'선택된 {len(selected_regulations)}개 법규를 각각 검색 중...'})
+
+                for i, regulation in enumerate(selected_regulations):
+                    if session_id not in active_sessions:
+                        emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
+                        emit('search_status', {'status': 'processing', 'message': 'Ready to search'})
+                        return
+                        
+                    regulation_title = regulation.get('title', '')
+                    regulation_id = regulation.get('id', '')
+                    regulation_type = regulation.get('type', 'part')  # 타입 정보 추출
+
+                    emit('search_status', {
+                        'status': 'searching_regulation', 
+                        'message': f'법규 {i+1}/{len(selected_regulations)}: [{regulation_type.upper()}] {regulation_title} 검색 중...',
+                        'progress': (i / len(selected_regulations)) * 100
+                    })
+
+                    # 법규 타입별 필터 생성
+                    current_filters = create_filter_by_type(regulation_type, regulation_title)
+                    print(f"[{regulation_type}] 필터에 추가: {regulation_title}")
+                    print(f"생성된 필터: {current_filters}")
+
+                    Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, current_filters)
+                    
+                    if session_id not in active_sessions:
+                        emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
+                        emit('search_status', {'status': 'processing', 'message': 'Ready to search'})
+                        return
+                        
+                    emit('search_status', {
+                        'status': 'ai_processing', 
+                        'message': f'AI가 [{regulation_type.upper()}] {regulation_title}에 대한 답변을 생성 중...'
+                    })
+                    
+                    AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
+                    logger.info(f"Answer: {AImessage}")
+
+                    if session_id not in active_sessions:
+                        emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
+                        return
+
+                    # 각 법규별 결과를 실시간으로 전송 (타입 정보 포함)
+                    emit('regulation_result', {
+                        'regulation_title': f"[{regulation_type.upper()}] {regulation_title}",
+                        'regulation_index': i + 1,
+                        'total_regulations': len(selected_regulations),
+                        'regulation_type': regulation_type,
+                        'result': AImessage
+                    })
+
+                    # 파일에 저장
+                    if isinstance(AImessage, str) and AImessage.strip():
+                        with open(output_path, "a", encoding="utf-8") as f:
+                            cont_selected_num += 1
+                            from datetime import datetime
+                            stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            f.write(f"\n--- [{stamp}] message #{cont_selected_num} --- Regulation Type: {regulation_type} --- Regulation Name : {regulation_title} ---\n {AImessage}")
+
+                emit('search_complete', {'status': 'completed', 'message': '모든 법규 검색이 완료되었습니다.'})
+            else:
+                # 통합 검색 모드 - 타입별로 그룹화
+                grouped_regulations = group_regulations_by_type(selected_regulations)
+                emit('search_status', {'status': 'searching', 'message': f'선택된 {len(selected_regulations)}개 법규를 타입별로 통합하여 검색 중...'})
+                
+                # 타입별로 필터 생성
+                combined_filters = create_combined_filters(grouped_regulations)
+                logger.info(f"통합 필터: {combined_filters}")
+
+                Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, combined_filters)
+                
+                if session_id in active_sessions:
+                    emit('search_status', {'status': 'ai_processing', 'message': 'AI가 통합 답변을 생성 중...'})
+                    AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
+                    logger.info(f"Answer: {AImessage}")
+                    
+                    if session_id in active_sessions:
+                        emit('search_result', {'result': AImessage})
+                        emit('search_complete', {'status': 'completed', 'message': '통합 검색이 완료되었습니다.'})
+
+        else:
+            Filtered_search = False
+            emit('search_status', {'status': 'searching_all', 'message': '전체 법규에서 검색 중...'})
+            
+            # 필터 없이 검색
+            Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, None)
+            
+            if session_id in active_sessions:
+                emit('search_status', {'status': 'ai_processing', 'message': 'AI가 답변을 생성 중...'})
+                AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
+                logger.info(f"Answer: {AImessage}")
+                
+                if session_id in active_sessions:
+                    emit('search_result', {'result': AImessage})
+                    emit('search_complete', {'status': 'completed', 'message': '검색이 완료되었습니다.'})
+
+    except Exception as e:
+        print(f"검색 오류: {e}")
+        emit('search_error', {'error': str(e), 'message': '검색 중 오류가 발생했습니다.'})
+    finally:
+        # 세션 정리
+        if session_id in active_sessions:
+            del active_sessions[session_id]
+
+
+@socketio.on('cancel_search')
+def handle_cancel_search(data):
+    session_id = data.get('session_id')
+    if session_id and session_id in active_sessions:
+        del active_sessions[session_id]
+        emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
 
-    return jsonify(message=AImessage)
 
 # --- 법규 리스트 ---
 @app.route('/get_reg_list', methods=['POST'])
@@ -280,7 +439,6 @@ def Gemma3_AI_Translate(query_txt):
 # --- 검색 ---
 def search_DB_from_multiple_regions(query, selected_regions, region_rag_objects):
     selected_regions = selected_regions or list(region_rag_objects.keys())
-    query = Gemma3_AI_Translate(query)
     logger.info(f"번역된 쿼리: {query}")
 
     combined_results = []
@@ -336,6 +494,60 @@ def RegAI(query, Rag_Results, ResultFile_FolderAddress):
 
     return AI_Result
 
+# 법규 타입별 필터 생성 함수
+def create_filter_by_type(regulation_type, regulation_title):
+    """법규 타입에 따라 적절한 필터 딕셔너리 생성"""
+    filter_dict = {
+        "regulation_part": [],
+        "regulation_section": [], 
+        "chapter_section": [],
+        "jo": []
+    }
+    
+    # 타입별 매핑
+    type_mapping = {
+        "part": "regulation_part",
+        "section": "regulation_section", 
+        "chapter": "chapter_section",
+        "jo": "jo"
+    }
+    
+    filter_key = type_mapping.get(regulation_type, "regulation_part")
+    filter_dict[filter_key].append(regulation_title)
+    
+    return filter_dict
+
+# 법규들을 타입별로 그룹화하는 함수
+def group_regulations_by_type(selected_regulations):
+    """선택된 법규들을 타입별로 그룹화"""
+    grouped = {
+        "part": [],
+        "section": [], 
+        "chapter": [],
+        "jo": []
+    }
+    
+    for regulation in selected_regulations:
+        regulation_type = regulation.get('type', 'part')
+        regulation_title = regulation.get('title', '')
+        
+        if regulation_title and regulation_type in grouped:
+            grouped[regulation_type].append(regulation_title)
+    
+    return grouped
+
+# 통합 필터 생성 함수
+def create_combined_filters(grouped_regulations):
+    """그룹화된 법규들로부터 통합 필터 생성"""
+    filters = {
+        "regulation_part": grouped_regulations["part"],
+        "regulation_section": grouped_regulations["section"], 
+        "chapter_section": grouped_regulations["chapter"],
+        "jo": grouped_regulations["jo"]
+    }
+    
+    return filters
+
 # --- 실행 ---
 if __name__ == '__main__':
     # 로컬 개발용