Merge pull request #16 from davidkim205/branch/15

api_server.py

@@ -83,23 +83,110 @@ sys.stdout = _stdout_proxy
 
 class PersonaRequest(BaseModel):
     info: str
+    stream: bool = True
+
+
+PERSONA_STATUS_MESSAGES = [
+    "인물 정보 수집 중...",
+    "웹 검색을 통해 배경 조사 중...",
+    "금융 사고 방식 분석 중...",
+    "데이터 분석 접근법 평가 중...",
+    "답변 스타일 특성 파악 중...",
+    "핵심 투자 원칙 추출 중...",
+    "대표 어록 정리 중...",
+    "페르소나 프로필 구성 중...",
+    "최종 검증 및 저장 준비 중...",
+]
+
+
+def _build_persona_payload(persona) -> dict:
+    return {
+        "type": "result",
+        "name": persona.name,
+        "full_name": persona.full_name,
+        "summary": persona.summary,
+        "financial_mindset": persona.financial_mindset,
+        "data_analysis_approach": persona.data_analysis_approach,
+        "response_style": persona.response_style,
+        "key_principles": persona.key_principles,
+        "famous_quotes": getattr(persona, "famous_quotes", None),
+    }
 
 
 @app.post("/persona/")
 async def create_persona(request: PersonaRequest):
     info = (request.info or "").strip()
+    stream = request.stream
+
     if not info:
         return JSONResponse(status_code=400, content={"error": "info 필드가 비어 있습니다."})
 
-    try:
-        persona = make_persona(info)
-    except Exception as exc:
-        return JSONResponse(status_code=500, content={"error": str(exc)})
+    if not stream:
+        try:
+            persona = make_persona(info)
+        except Exception as exc:
+            return JSONResponse(status_code=500, content={"error": str(exc)})
+
+        if persona is None:
+            return JSONResponse(status_code=500, content={"error": "페르소나 생성에 실패했습니다."})
+
+        return JSONResponse(content=persona.model_dump())
+
+    def event_stream():
+        event_queue: Queue = Queue()
+
+        def status_sender():
+            import asyncio
+
+            async def send_status():
+                for i, message in enumerate(PERSONA_STATUS_MESSAGES[:-1]):  # 마지막 메시지는 완료 시점에 사용
+                    event_queue.put({"type": "status", "message": message})
+                    await asyncio.sleep(8)
+
+            # 비동기 이벤트 루프에서 실행
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(send_status())
+
+        def worker():
+            thread_id = threading.get_ident()
+            _stdout_proxy.register(thread_id, _QueueingStdoutTee(_stdout_proxy._target, event_queue))
+            try:
+                # status 메시지 전송 스레드 시작
+                status_thread = Thread(target=status_sender, daemon=True)
+                status_thread.start()
+
+                persona = make_persona(info)
+
+                if persona is None:
+                    event_queue.put({"type": "error", "message": "페르소나 생성에 실패했습니다."})
+                else:
+                    event_queue.put(_build_persona_payload(persona))
+            except Exception as exc:
+                event_queue.put({"type": "error", "message": str(exc)})
+            finally:
+                _stdout_proxy.unregister(thread_id)
+                event_queue.put({"type": "done"})
+
+        yield _sse({"type": "status", "message": "페르소나 생성 준비 중..."})
+        Thread(target=worker, daemon=True).start()
 
-    if persona is None:
-        return JSONResponse(status_code=500, content={"error": "페르소나 생성에 실패했습니다."})
+        done = False
+        while not done:
+            try:
+                event = event_queue.get(timeout=0.2)
+            except Empty:
+                continue
+            yield _sse(jsonable_encoder(event))
+            if event.get("type") == "done":
+                done = True
 
-    return JSONResponse(content=persona.model_dump())
+    headers = {
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "X-Accel-Buffering": "no",
+    }
+    return StreamingResponse(event_stream(), media_type="text/event-stream", headers=headers)
 
 class QueryRequest(BaseModel):
     query: str

gradio_app.py

@@ -126,7 +126,7 @@ def _status_icon(msg):
 class PersonaLine(BaseModel):
     name: str
     full_name: str
-    background: str
+    summary: str
     financial_mindset: str
     data_analysis_approach: str
     response_style: str
@@ -169,6 +169,9 @@ def _parse_personas():
                         continue
                     if not data.get("full_name"):
                         data["full_name"] = data.get("name", "")
+                    # 호환성: background 필드가 있으면 summary로 복사
+                    if "background" in data and "summary" not in data:
+                        data["summary"] = data["background"]
                     personas.append(PersonaLine(**data))
                 except (json.JSONDecodeError, TypeError, ValidationError):
                     continue
@@ -246,7 +249,7 @@ def build_profile_html(p: PersonaLine):
     <div class="pf-header-info">
       <h2 class="pf-name">{_safe(p.full_name)}</h2>
       <p class="pf-subtitle">{_safe(p.title or "")}{("&nbsp;·&nbsp;" + _safe(p.company)) if p.company else ""}</p>
-      <p class="pf-bg">{_safe(p.background)}</p>
+      <p class="pf-bg">{_safe(p.summary)}</p>
     </div>
   </div>
   {('<div class="pf-meta-grid">' + "".join(meta_rows) + '</div>') if meta_rows else ''}
@@ -388,7 +391,7 @@ def _fetch_from_multi_wiki(name):
             continue
     return ""
 
-def _fetch_wikipedia_image(full_name, background=None):
+def _fetch_wikipedia_image(full_name, summary=None):
 
     # 1. Wikidata (가장 강력)
     img = _wikidata_image(full_name)
@@ -407,8 +410,8 @@ def _fetch_wikipedia_image(full_name, background=None):
     _translate_to_english_name(full_name),
     ]
 
-    if background:
-        queries.append(_extract_english_keywords(background))
+    if summary:
+        queries.append(_extract_english_keywords(summary))
         
     for q in queries:
         headers = {"User-Agent": "Mozilla/5.0"}
@@ -437,7 +440,7 @@ def generate_persona_image(name: str) -> str:
         return cache_path.read_text()
 
     try:
-        data_url = _fetch_wikipedia_image(persona.full_name, persona.background)
+        data_url = _fetch_wikipedia_image(persona.full_name, persona.summary)
         if data_url:
             cache_path.write_text(data_url)
             return data_url
@@ -692,49 +695,100 @@ def generate_persona_stream(info, endpoint):
 
     persona_ep = endpoint.rstrip("/").rsplit("/", 1)[0] + "/persona/"
     elapsed = _make_elapsed()
-    q: Queue = Queue()
+    eq: Queue = Queue()
 
-    def worker():
+    def reader():
         try:
-            r = requests.post(persona_ep, json={"info": info.strip()}, timeout=(10, 300))
-            r.raise_for_status()
-            q.put(("ok", r.json()))
+            body = {"info": info.strip(), "stream": True}
+            with requests.post(persona_ep, json=body,
+                               headers={"Accept": "text/event-stream"},
+                               stream=True, timeout=(10, 300)) as resp:
+                resp.raise_for_status()
+                for raw in resp.iter_lines(chunk_size=1, decode_unicode=True):
+                    if not raw: continue
+                    line = raw.strip()
+                    if not line.startswith("data:"): continue
+                    try:
+                        eq.put(("event", json.loads(line[5:].strip())))
+                    except json.JSONDecodeError:
+                        continue
         except requests.exceptions.ConnectionError:
-            q.put(("error", f"연결 실패: {persona_ep}"))
+            eq.put(("exception", f"연결 실패: {persona_ep}"))
         except requests.exceptions.Timeout:
-            q.put(("error", "요청 시간 초과"))
+            eq.put(("exception", "요청 시간 초과"))
         except requests.RequestException as e:
-            q.put(("error", f"요청 실패: {e}"))
+            eq.put(("exception", f"요청 실패: {e}"))
+        finally:
+            eq.put(("worker_done", None))
 
-    Thread(target=worker, daemon=True).start()
+    Thread(target=reader, daemon=True).start()
+
+    log_lines = []
+    result_data = None
+    worker_done = False
 
     while True:
         try:
-            kind, payload = q.get_nowait(); break
+            kind, payload = eq.get(timeout=0.1)
+            buf = [(kind, payload)]
+            while True:
+                try: buf.append(eq.get_nowait())
+                except Empty: break
         except Empty:
-            yield (
-                '<div class="ws-loading shimmer"><div class="ws-loading-title">⏳ 페르소나 생성 중...</div>'
-                '<div class="ws-loading-msg">AI가 인물 정보를 검색하고 있습니다</div></div>',
-                "{}", timer_text(elapsed())
-            )
-            time.sleep(0.3)
+            buf = []
 
-    if kind == "error":
-        yield payload, "{}", timer_text(elapsed())
-        return
+        for kind, payload in buf:
+            if kind == "event":
+                et = payload.get("type")
+
+                if et == "status":
+                    msg = payload.get("message", "")
+                    if msg:
+                        log_lines.append(("status", msg))
+
+                elif et == "result":
+                    result_data = payload
+                    log_lines.append(("done", "페르소나 생성 완료"))
+
+                elif et == "error":
+                    msg = payload.get("message", "오류 발생")
+                    log_lines.append(("error", msg))
+
+                elif et == "done":
+                    pass  # 이미 result에서 처리
 
-    data = payload
-    md = "\n\n".join([
-        f"**이름**: {data.get('name','')}",
-        f"**배경**: {data.get('background','')}",
-        f"**금융 사고 방식**: {data.get('financial_mindset','')}",
-        f"**데이터 분석 방식**: {data.get('data_analysis_approach','')}",
-        f"**답변 스타일**: {data.get('response_style','')}",
-        f"**핵심 원칙**: {', '.join(data.get('key_principles',[]))}",
-    ])
-    if data.get("famous_quotes"):
-        md += f"\n\n**어록**: {' / '.join(data['famous_quotes'])}"
-    yield md, json.dumps(data, ensure_ascii=False, indent=2), timer_text(elapsed())
+            elif kind == "exception":
+                log_lines.append(("error", str(payload)))
+
+            elif kind == "worker_done":
+                worker_done = True
+
+        t = timer_text(elapsed())
+        if result_data:
+            # 최종 결과 표시
+            data = result_data
+            md = "\n\n".join([
+                f"**이름**: {data.get('name','')}",
+                f"**배경**: {data.get('summary','')}",
+                f"**금융 사고 방식**: {data.get('financial_mindset','')}",
+                f"**데이터 분석 방식**: {data.get('data_analysis_approach','')}",
+                f"**답변 스타일**: {data.get('response_style','')}",
+                f"**핵심 원칙**: {', '.join(data.get('key_principles',[]))}",
+            ])
+            if data.get("famous_quotes"):
+                md += f"\n\n**어록**: {' / '.join(data['famous_quotes'])}"
+            yield md, json.dumps(data, ensure_ascii=False, indent=2), t
+            break
+        else:
+            # 진행 상황 표시
+            panel = _wrap_log(_make_log_html(log_lines))
+            yield panel, "{}", t
+
+        if worker_done and not result_data:
+            # 오류 발생 시
+            panel = _wrap_log(_make_log_html(log_lines))
+            yield panel, "{}", t
+            break
 
 
 # ─────────────────────────────────────────────────────────────

llm/generator.py

@@ -62,7 +62,7 @@ def generate_news_info(client, user_query, intent):
 class Persona(BaseModel):
     name: str                        # 인물 이름
     full_name: str                   # 인물 이름
-    background: str                  # 인물 배경 (경력, 주요 업적 등)
+    summary: str                     # 인물 요약 (간단한 소개)
     financial_mindset: str           # 금융 사고 방식
     data_analysis_approach: str      # 데이터 분석 방식
     response_style: str              # 질문에 대한 답변 스타일
@@ -76,6 +76,7 @@ def generate_persona(client, user_query):
         "- full_name: 인물의 원문/정식 전체 이름.\n"
         "- name: 사용자가 이해하기 쉬운 표시 이름(한국어 통용명 우선, 없으면 간결한 영어).\n"
         "- 괄호 별칭/원문 병기는 full_name에만 포함하고 name에는 넣지 말 것.\n"
+        "- summary: 인물의 간단한 소개 요약 (2-3문장 정도로 간결하게).\n"
         "나머지 필드는 사실 기반으로 충실히 작성하시오."
     )
 
@@ -123,7 +124,7 @@ def build_full_prompt(user_query, context, intent, persona=None):
 
 [선택된 페르소나]
 이름: {persona.name}
-배경: {persona.background}
+요약: {persona.summary}
 금융 사고방식: {persona.financial_mindset}
 데이터 분석 방식: {persona.data_analysis_approach}
 답변 스타일: {persona.response_style}

persona/make_persona.py

@@ -68,13 +68,13 @@ def save_persona_jsonl(persona, query, file_name=None):
 def print_persona(persona):
     print("\n[Persona 생성 결과]")
     print(f"- 이름: {persona.name}")
-    print(f"- 배경: {persona.background}")
+    print(f"- 요약: {persona.summary}")
     print(f"- 금융 사고 방식: {persona.financial_mindset}")
     print(f"- 데이터 분석 방식: {persona.data_analysis_approach}")
     print(f"- 답변 스타일: {persona.response_style}")
-    print(f"- 핵심 원칙: {', '.join(persona.key_principles)}")
+    print(f"- 핵심 원칙: {', '.join(persona.key_principles)}", flush=True)
     if getattr(persona, "famous_quotes", None):
-        print(f"- 어록: {', '.join(persona.famous_quotes)}")
+        print(f"- 어록: {', '.join(persona.famous_quotes)}", flush=True)
 
 
 def make_persona(info):

persona/persona_loader.py

@@ -13,6 +13,10 @@ def load_personas():
                 line = line.strip()
                 if line:
                     data = json.loads(line)
+                    # 호환성: background 필드가 있으면 summary로 매핑
+                    if isinstance(data, dict) and "background" in data and "summary" not in data:
+                        data["summary"] = data["background"]
+                        # background 필드는 제거하지 않고 유지 (호환성)
                     # full_name 없으면 name 사용하여 채움
                     if isinstance(data, dict) and not data.get("full_name"):
                         data["full_name"] = data.get("name", "")