Update app-backup.py

app-backup.py

@@ -40,6 +40,23 @@ else:
 PROMPT_PDF_PATH = BASE / "prompt.pdf"
 PROMPT_PDF_ID = "prompt_pdf_main"
 
+# 다중 PDF 지원
+PDF_FILES = {
+    "prompt": {
+        "path": BASE / "prompt.pdf",
+        "id": "prompt_pdf_main",
+        "name": "샘플-프롬프트북"
+    },
+    "ktx": {
+        "path": BASE / "ktx2512.pdf",
+        "id": "ktx_pdf_main",
+        "name": "샘플-코레일잡지"
+    }
+}
+
+# 현재 선택된 PDF (기본값: prompt)
+current_pdf_key = "prompt"
+
 pdf_cache: Dict[str, Dict[str, Any]] = {}
 cache_locks = {}
 pdf_embeddings: Dict[str, Dict[str, Any]] = {}
@@ -602,21 +619,186 @@ async def startup_event():
         logger.warning(f"prompt.pdf 파일을 찾을 수 없습니다: {PROMPT_PDF_PATH}")
 
 
+@app.get("/api/pdf-list")
+async def get_pdf_list():
+    """사용 가능한 PDF 목록 반환"""
+    global current_pdf_key
+    pdf_list = []
+    for key, info in PDF_FILES.items():
+        pdf_list.append({
+            "key": key,
+            "name": info["name"],
+            "exists": info["path"].exists(),
+            "is_current": key == current_pdf_key
+        })
+    return {"pdfs": pdf_list, "current": current_pdf_key}
+
+
+@app.post("/api/switch-pdf/{pdf_key}")
+async def switch_pdf(pdf_key: str, background_tasks: BackgroundTasks):
+    """PDF 전환"""
+    global current_pdf_key
+    
+    if pdf_key not in PDF_FILES:
+        return JSONResponse(content={"error": "유효하지 않은 PDF 키입니다."}, status_code=400)
+    
+    pdf_info = PDF_FILES[pdf_key]
+    if not pdf_info["path"].exists():
+        return JSONResponse(content={"error": f"PDF 파일을 찾을 수 없습니다: {pdf_info['name']}"}, status_code=404)
+    
+    current_pdf_key = pdf_key
+    logger.info(f"PDF 전환: {pdf_key} - {pdf_info['name']}")
+    
+    # 캐싱 시작
+    pdf_name = pdf_info["path"].stem
+    if pdf_name not in pdf_cache or pdf_cache[pdf_name].get("status") != "completed":
+        background_tasks.add_task(cache_pdf, str(pdf_info["path"]))
+    
+    # VLM 분석 시작 (캐시가 없는 경우)
+    if not load_analysis_cache(pdf_info["id"]):
+        asyncio.create_task(analyze_pdf_with_vlm_batched_for_key(pdf_key))
+    
+    return {
+        "success": True,
+        "current": pdf_key,
+        "name": pdf_info["name"],
+        "id": pdf_info["id"]
+    }
+
+
+async def analyze_pdf_with_vlm_batched_for_key(pdf_key: str, force_refresh: bool = False) -> Dict[str, Any]:
+    """특정 PDF에 대한 VLM 분석"""
+    global analysis_status
+    
+    if pdf_key not in PDF_FILES:
+        return {"error": "유효하지 않은 PDF 키"}
+    
+    pdf_info = PDF_FILES[pdf_key]
+    pdf_id = pdf_info["id"]
+    pdf_path = str(pdf_info["path"])
+    
+    # 이미 분석 중인지 확인
+    if pdf_id in analysis_status and analysis_status[pdf_id].get("status") == "analyzing":
+        logger.info(f"PDF {pdf_id} 이미 분석 중...")
+        return {"status": "analyzing", "progress": analysis_status[pdf_id].get("progress", 0)}
+    
+    # 캐시 확인
+    if not force_refresh:
+        cached = load_analysis_cache(pdf_id)
+        if cached:
+            analysis_status[pdf_id] = {"status": "completed", "progress": 100}
+            return cached
+    
+    if not pdf_info["path"].exists():
+        analysis_status[pdf_id] = {"status": "error", "error": "PDF 파일 없음"}
+        return {"error": "PDF 파일을 찾을 수 없습니다."}
+    
+    if not HAS_VALID_API_KEY:
+        analysis_status[pdf_id] = {"status": "error", "error": "API 키 없음"}
+        return {"error": "API 키가 설정되지 않았습니다."}
+    
+    # 분석 시작
+    analysis_status[pdf_id] = {"status": "analyzing", "progress": 0, "started_at": time.time()}
+    
+    try:
+        doc = fitz.open(pdf_path)
+        total_pages = doc.page_count
+        doc.close()
+        
+        logger.info(f"PDF 분석 시작 ({pdf_key}): 총 {total_pages}페이지")
+        
+        batch_size = 5
+        all_analyses = []
+        
+        for start_page in range(0, min(total_pages, 25), batch_size):
+            try:
+                progress = int((start_page / min(total_pages, 25)) * 100)
+                analysis_status[pdf_id]["progress"] = progress
+                logger.info(f"배치 분석 중 ({pdf_key}): {start_page + 1}페이지부터 (진행률: {progress}%)")
+                
+                loop = asyncio.get_event_loop()
+                batch_result = await loop.run_in_executor(
+                    None, 
+                    analyze_batch_pages_sync, 
+                    pdf_path, 
+                    start_page, 
+                    batch_size
+                )
+                
+                if batch_result:
+                    all_analyses.append(f"### 페이지 {start_page + 1}~{min(start_page + batch_size, total_pages)}\n{batch_result}")
+                
+                await asyncio.sleep(2)
+                
+            except Exception as batch_error:
+                logger.error(f"배치 {start_page} 분석 오류: {batch_error}")
+                all_analyses.append(f"### 페이지 {start_page + 1}~{min(start_page + batch_size, total_pages)}\n[분석 실패: {str(batch_error)}]")
+        
+        combined_analysis = "\n\n".join(all_analyses)
+        
+        successful_analyses = [a for a in all_analyses if "[분석 실패:" not in a]
+        if not successful_analyses:
+            logger.error("모든 배치 분석 실패")
+            analysis_status[pdf_id] = {"status": "error", "error": "모든 페이지 분석 실패"}
+            return {"error": "PDF 분석에 실패했습니다."}
+        
+        summary = ""
+        if combined_analysis:
+            try:
+                summary_messages = [
+                    {"role": "system", "content": "다음 PDF 분석 내용을 500자 이내로 요약해주세요. 핵심 내용과 주요 키워드를 포함해주세요."},
+                    {"role": "user", "content": combined_analysis[:8000]}
+                ]
+                summary = call_fireworks_vlm_api(summary_messages, max_tokens=1024, temperature=0.5)
+            except Exception as sum_err:
+                logger.error(f"요약 생성 오류: {sum_err}")
+                summary = combined_analysis[:500] + "..."
+        
+        analysis_data = {
+            "pdf_id": pdf_id,
+            "pdf_key": pdf_key,
+            "total_pages": total_pages,
+            "analyzed_pages": min(total_pages, 25),
+            "analysis": combined_analysis,
+            "summary": summary,
+            "created_at": time.time()
+        }
+        
+        save_analysis_cache(pdf_id, analysis_data)
+        
+        analysis_status[pdf_id] = {"status": "completed", "progress": 100}
+        logger.info(f"PDF 분석 완료: {pdf_id}")
+        
+        return analysis_data
+        
+    except Exception as e:
+        logger.error(f"VLM PDF 분석 오류: {e}")
+        analysis_status[pdf_id] = {"status": "error", "error": str(e)}
+        return {"error": str(e)}
+
+
 @app.get("/api/pdf-info")
 async def get_pdf_info():
-    if not PROMPT_PDF_PATH.exists():
+    global current_pdf_key
+    pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+    pdf_path = pdf_info["path"]
+    pdf_id = pdf_info["id"]
+    
+    if not pdf_path.exists():
         return {"exists": False, "error": "PDF 파일을 찾을 수 없습니다"}
     
-    pdf_name = PROMPT_PDF_PATH.stem
+    pdf_name = pdf_path.stem
     is_cached = pdf_name in pdf_cache and pdf_cache[pdf_name].get("status") == "completed"
     
     # VLM 분석 캐시 확인
-    analysis_cached = load_analysis_cache(PROMPT_PDF_ID) is not None
+    analysis_cached = load_analysis_cache(pdf_id) is not None
     
     return {
-        "path": str(PROMPT_PDF_PATH),
+        "path": str(pdf_path),
         "name": pdf_name,
-        "id": PROMPT_PDF_ID,
+        "display_name": pdf_info["name"],
+        "id": pdf_id,
+        "key": current_pdf_key,
         "exists": True,
         "cached": is_cached,
         "analysis_cached": analysis_cached
@@ -626,8 +808,12 @@ async def get_pdf_info():
 @app.get("/api/analysis-status")
 async def get_analysis_status():
     """VLM 분석 상태 확인"""
+    global current_pdf_key
+    pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+    pdf_id = pdf_info["id"]
+    
     # 먼저 캐시 파일 확인
-    cached = load_analysis_cache(PROMPT_PDF_ID)
+    cached = load_analysis_cache(pdf_id)
     if cached:
         return {
             "status": "completed",
@@ -637,8 +823,8 @@ async def get_analysis_status():
         }
     
     # 메모리 상태 확인
-    if PROMPT_PDF_ID in analysis_status:
-        status_info = analysis_status[PROMPT_PDF_ID]
+    if pdf_id in analysis_status:
+        status_info = analysis_status[pdf_id]
         return {
             "status": status_info.get("status", "unknown"),
             "progress": status_info.get("progress", 0),
@@ -651,22 +837,26 @@ async def get_analysis_status():
 @app.post("/api/reanalyze-pdf")
 async def reanalyze_pdf():
     """PDF 재분석 (캐시 무시)"""
+    global current_pdf_key
     try:
         if not HAS_VALID_API_KEY:
             return JSONResponse(content={"error": "API 키가 설정되지 않았습니다."}, status_code=400)
         
+        pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+        pdf_id = pdf_info["id"]
+        
         # 기존 캐시 삭제
-        cache_path = get_analysis_cache_path(PROMPT_PDF_ID)
+        cache_path = get_analysis_cache_path(pdf_id)
         if cache_path.exists():
             cache_path.unlink()
             logger.info("기존 VLM 분석 캐시 삭제")
         
         # 상태 초기화
-        if PROMPT_PDF_ID in analysis_status:
-            del analysis_status[PROMPT_PDF_ID]
+        if pdf_id in analysis_status:
+            del analysis_status[pdf_id]
         
         # 백그라운드에서 재분석 시작
-        asyncio.create_task(run_initial_analysis())
+        asyncio.create_task(analyze_pdf_with_vlm_batched_for_key(current_pdf_key))
         
         return {"status": "started", "message": "PDF 재분석을 시작합니다."}
     except Exception as e:
@@ -676,22 +866,26 @@ async def reanalyze_pdf():
 
 @app.get("/api/pdf-thumbnail")
 async def get_pdf_thumbnail():
+    global current_pdf_key
     try:
-        if not PROMPT_PDF_PATH.exists():
+        pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+        pdf_path = pdf_info["path"]
+        
+        if not pdf_path.exists():
             return {"thumbnail": None, "error": "PDF 파일을 찾을 수 없습니다"}
         
-        pdf_name = PROMPT_PDF_PATH.stem
+        pdf_name = pdf_path.stem
         if pdf_name in pdf_cache and pdf_cache[pdf_name].get("pages"):
             if pdf_cache[pdf_name]["pages"][0].get("thumb"):
                 return {"thumbnail": pdf_cache[pdf_name]["pages"][0]["thumb"]}
 
-        doc = fitz.open(str(PROMPT_PDF_PATH))
+        doc = fitz.open(str(pdf_path))
         if doc.page_count > 0:
             page = doc[0]
             pix = page.get_pixmap(matrix=fitz.Matrix(0.2, 0.2))
             img_data = pix.tobytes("jpeg", 70)
             b64_img = base64.b64encode(img_data).decode('utf-8')
-            asyncio.create_task(cache_pdf(str(PROMPT_PDF_PATH)))
+            asyncio.create_task(cache_pdf(str(pdf_path)))
             return {"thumbnail": f"data:image/jpeg;base64,{b64_img}"}
         return {"thumbnail": None}
     except Exception as e:
@@ -701,7 +895,9 @@ async def get_pdf_thumbnail():
 
 @app.get("/api/cache-status")
 async def get_cache_status():
-    pdf_name = PROMPT_PDF_PATH.stem
+    global current_pdf_key
+    pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+    pdf_name = pdf_info["path"].stem
     if pdf_name in pdf_cache:
         return pdf_cache[pdf_name]
     return {"status": "not_cached"}
@@ -709,15 +905,17 @@ async def get_cache_status():
 
 @app.post("/api/ai/query-pdf")
 async def api_query_pdf(query: Dict[str, str]):
+    global current_pdf_key
     try:
         user_query = query.get("query", "")
         if not user_query:
             return JSONResponse(content={"error": "질문이 제공되지 않았습니다"}, status_code=400)
 
-        if not PROMPT_PDF_PATH.exists():
+        pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+        if not pdf_info["path"].exists():
             return JSONResponse(content={"error": "PDF 파일을 찾을 수 없습니다"}, status_code=404)
 
-        result = await query_pdf(PROMPT_PDF_ID, user_query)
+        result = await query_pdf(pdf_info["id"], user_query)
         if "answer" in result:
             return result
         if "error" in result:
@@ -730,11 +928,13 @@ async def api_query_pdf(query: Dict[str, str]):
 
 @app.get("/api/ai/summarize-pdf")
 async def api_summarize_pdf():
+    global current_pdf_key
     try:
-        if not PROMPT_PDF_PATH.exists():
+        pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+        if not pdf_info["path"].exists():
             return JSONResponse(content={"error": "PDF 파일을 찾을 수 없습니다"}, status_code=404)
 
-        result = await summarize_pdf(PROMPT_PDF_ID)
+        result = await summarize_pdf(pdf_info["id"])
         if "summary" in result:
             return result
         if "error" in result:
@@ -747,8 +947,12 @@ async def api_summarize_pdf():
 
 @app.get("/api/cached-pdf")
 async def get_cached_pdf(background_tasks: BackgroundTasks):
+    global current_pdf_key
     try:
-        pdf_name = PROMPT_PDF_PATH.stem
+        pdf_info = PDF_FILES.get(current_pdf_key, PDF_FILES["prompt"])
+        pdf_path = pdf_info["path"]
+        pdf_name = pdf_path.stem
+        
         if pdf_name in pdf_cache:
             status = pdf_cache[pdf_name].get("status", "")
             if status == "completed":
@@ -765,7 +969,7 @@ async def get_cached_pdf(background_tasks: BackgroundTasks):
                     "available_pages": len([p for p in pages if p and p.get("src")])
                 }
 
-        background_tasks.add_task(cache_pdf, str(PROMPT_PDF_PATH))
+        background_tasks.add_task(cache_pdf, str(pdf_path))
         return {"status": "started", "progress": 0}
     except Exception as e:
         logger.error(f"캐시된 PDF 제공 오류: {str(e)}")
@@ -927,6 +1131,94 @@ HTML = """
     transform: translateX(0);
   }
 
+  /* PDF Selection Buttons */
+  .floating-pdf-btn {
+    position: fixed;
+    right: 20px;
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #3B82F6 0%, #8B5CF6 100%);
+    border: 3px solid #1F2937;
+    box-shadow: 4px 4px 0 #1F2937;
+    z-index: 9998;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    cursor: pointer;
+    transition: var(--transition);
+    overflow: hidden;
+  }
+
+  #pdfPromptBtn {
+    top: 70px;
+  }
+
+  #pdfKtxBtn {
+    top: 130px;
+  }
+
+  .floating-pdf-btn:hover {
+    transform: translate(-2px, -2px);
+    box-shadow: 6px 6px 0 #1F2937;
+  }
+
+  .floating-pdf-btn:active {
+    transform: translate(2px, 2px);
+    box-shadow: 2px 2px 0 #1F2937;
+  }
+
+  .floating-pdf-btn.active {
+    background: linear-gradient(135deg, #10B981 0%, #059669 100%);
+    box-shadow: 4px 4px 0 #065F46;
+  }
+
+  .floating-pdf-btn .icon {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+    font-size: 18px;
+    color: white;
+    text-shadow: 1px 1px 0 #1F2937;
+    transition: var(--transition);
+  }
+
+  .floating-pdf-btn .pdf-title {
+    position: absolute;
+    right: 58px;
+    background: #FFF;
+    padding: 8px 14px;
+    border-radius: 8px;
+    border: 2px solid #1F2937;
+    box-shadow: 3px 3px 0 #1F2937;
+    font-family: 'Comic Neue', cursive;
+    font-size: 0.85rem;
+    font-weight: 700;
+    letter-spacing: 0.5px;
+    white-space: nowrap;
+    pointer-events: none;
+    opacity: 0;
+    transform: translateX(10px);
+    transition: all 0.3s ease;
+    color: var(--text-dark);
+  }
+
+  .floating-pdf-btn:hover .pdf-title {
+    opacity: 1;
+    transform: translateX(0);
+  }
+
+  .floating-pdf-btn.loading {
+    pointer-events: none;
+    opacity: 0.7;
+  }
+
+  .floating-pdf-btn.loading .icon {
+    animation: spin 1s linear infinite;
+  }
+
   /* Viewer Container - Comic Style */
   #viewer {
     width: 94%;
@@ -1398,22 +1690,43 @@ HTML = """
     .header-info {
       top: 8px;
       padding: 6px 15px;
-      max-width: 70%;
+      max-width: 60%;
     }
     
     .header-info .title {
-      font-size: 1.1rem;
+      font-size: 1rem;
     }
     
     .floating-ai {
-      width: 45px;
-      height: 45px;
+      width: 40px;
+      height: 40px;
       top: 8px;
       right: 10px;
     }
     
     .floating-ai .icon {
-      font-size: 18px;
+      font-size: 16px;
+    }
+
+    .floating-pdf-btn {
+      width: 40px;
+      height: 40px;
+    }
+
+    #pdfPromptBtn {
+      top: 55px;
+    }
+
+    #pdfKtxBtn {
+      top: 102px;
+    }
+
+    .floating-pdf-btn .icon {
+      font-size: 14px;
+    }
+
+    .floating-pdf-btn .pdf-title {
+      display: none;
     }
     
     #aiChatContainer {
@@ -1444,6 +1757,16 @@ HTML = """
     <div class="ai-title">🤖 AI 어시스턴트</div>
   </div>
 
+  <!-- PDF Selection Buttons -->
+  <div id="pdfPromptBtn" class="floating-pdf-btn active" data-pdf="prompt">
+    <div class="icon"><i class="fas fa-book"></i></div>
+    <div class="pdf-title">샘플-프롬프트북</div>
+  </div>
+  <div id="pdfKtxBtn" class="floating-pdf-btn" data-pdf="ktx">
+    <div class="icon"><i class="fas fa-train"></i></div>
+    <div class="pdf-title">샘플-코레일잡지</div>
+  </div>
+
   <!-- AI Chat Container -->
   <div id="aiChatContainer">
     <div id="aiChatHeader">
@@ -1479,6 +1802,8 @@ HTML = """
     let isAiProcessing = false;
     let hasLoadedSummary = false;
     let analysisCheckInterval = null;
+    let currentPdfKey = 'prompt';
+    let isPdfSwitching = false;
 
     function $id(id) { return document.getElementById(id); }
 
@@ -1853,6 +2178,77 @@ HTML = """
       }
     }
 
+    async function switchPDF(pdfKey) {
+      if (isPdfSwitching || pdfKey === currentPdfKey) return;
+      
+      try {
+        isPdfSwitching = true;
+        
+        // 버튼 상태 업데이트
+        document.querySelectorAll('.floating-pdf-btn').forEach(btn => {
+          btn.classList.remove('active');
+          if (btn.dataset.pdf === pdfKey) {
+            btn.classList.add('loading');
+          }
+        });
+        
+        showLoading("PDF 전환 중...");
+        
+        // 서버에 PDF 전환 요청
+        const switchResponse = await fetch(`/api/switch-pdf/${pdfKey}`, { method: 'POST' });
+        const switchResult = await switchResponse.json();
+        
+        if (!switchResult.success) {
+          hideLoading();
+          showError(switchResult.error || "PDF 전환에 실패했습니다.");
+          isPdfSwitching = false;
+          document.querySelectorAll('.floating-pdf-btn').forEach(btn => {
+            btn.classList.remove('loading');
+            if (btn.dataset.pdf === currentPdfKey) btn.classList.add('active');
+          });
+          return;
+        }
+        
+        currentPdfKey = pdfKey;
+        
+        // 기존 FlipBook 제거
+        if (fb) {
+          viewer.innerHTML = '';
+          fb = null;
+        }
+        
+        // AI 챗봇 초기화
+        hasLoadedSummary = false;
+        $id('aiChatMessages').innerHTML = '';
+        if (analysisCheckInterval) {
+          clearInterval(analysisCheckInterval);
+          analysisCheckInterval = null;
+        }
+        
+        // 새 PDF 로드
+        await loadPDF();
+        
+        // 버튼 상태 최종 업데이트
+        document.querySelectorAll('.floating-pdf-btn').forEach(btn => {
+          btn.classList.remove('loading');
+          btn.classList.remove('active');
+          if (btn.dataset.pdf === pdfKey) btn.classList.add('active');
+        });
+        
+        isPdfSwitching = false;
+        
+      } catch (error) {
+        console.error("PDF 전환 오류:", error);
+        hideLoading();
+        showError("PDF 전환 중 오류�� 발생했습니다.");
+        isPdfSwitching = false;
+        document.querySelectorAll('.floating-pdf-btn').forEach(btn => {
+          btn.classList.remove('loading');
+          if (btn.dataset.pdf === currentPdfKey) btn.classList.add('active');
+        });
+      }
+    }
+
     async function loadPDF() {
       try {
         showLoading("PDF 정보 확인 중...");
@@ -1934,6 +2330,10 @@ HTML = """
         }
       });
 
+      // PDF 선택 버튼 이벤트
+      $id('pdfPromptBtn').addEventListener('click', () => switchPDF('prompt'));
+      $id('pdfKtxBtn').addEventListener('click', () => switchPDF('ktx'));
+
       loadPDF();
     });
 </script>