Update app.py

app.py

@@ -4,6 +4,7 @@ import openai
 import requests
 import logging
 
+# ===== (기본코드 시작) =====
 # 로깅 설정
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -115,7 +116,6 @@ with gr.Blocks() as iface:
             output_box = gr.Textbox(label=category, visible=True)
             output_boxes[category] = output_box
 
-    # 기존 동기 함수 (수정/삭제 금지)
     def validate_and_generate(topic):
         try:
             results = generate_copywriting(CATEGORIES, topic)
@@ -132,127 +132,112 @@ with gr.Blocks() as iface:
         except Exception as e:
             logger.error(f"Error during copywriting generation: {str(e)}")
             return [gr.update(value=f"오류 발생: {str(e)}")] + [gr.update(value="") for _ in CATEGORIES]
-    
-    ##########################################
-    # 추가된 비동기/병렬 처리용 코드 시작
-    ##########################################
-    import asyncio
-    import aiohttp
 
-    async def call_api_async(content, system_message, max_tokens, temperature, top_p):
-        """
-        비동기적으로 OpenAI API를 호출하는 함수
-        """
-        url = "https://api.openai.com/v1/chat/completions"
-        headers = {"Authorization": f"Bearer {openai.api_key}"}
-        payload = {
-            "model": "gpt-4o-mini",
-            "messages": [
-                {"role": "system", "content": system_message},
-                {"role": "user", "content": content},
-            ],
-            "max_tokens": max_tokens,
-            "temperature": temperature,
-            "top_p": top_p,
-        }
-        async with aiohttp.ClientSession() as session:
-            async with session.post(url, headers=headers, json=payload) as resp:
-                resp_json = await resp.json()
-                return resp_json["choices"][0]["message"]["content"]
+    generate_btn.click(
+        fn=validate_and_generate,
+        inputs=[topic],
+        outputs=[status] + [output_boxes[category] for category in CATEGORIES]
+    )
+
+# 인터페이스 실행
+iface.launch()
+# ===== (기본코드 끝) =====
 
-    async def generate_copywriting_async(categories, topic):
-        """
-        여러 카테고리에 대해 비동기적으로 카피라이팅을 생성하는 함수
-        """
-        max_tokens = 1000
-        temperature = 0.8
-        top_p = 0.95
 
-        tasks = []
-        for category in categories:
-            prompt = get_category_prompt(category)
-            user_content = f"주제: {topic}"
-            tasks.append(
-                asyncio.create_task(
-                    call_api_async(user_content, prompt, max_tokens, temperature, top_p)
-                )
-            )
-        
-        # 병렬 실행
-        results = await asyncio.gather(*tasks)
-        
-        # category 순서에 맞춰 딕셔너리화
-        result_dict = {}
-        for category, copywriting in zip(categories, results):
-            result_dict[category] = copywriting
-        
-        return result_dict
+# ===== (아래부터 비동기/병렬 구조 추가 코드) =====
+import asyncio
+import aiohttp
 
-    async def validate_and_generate_async(topic):
-        """
-        Gradio에서 스트리밍(yield)을 통해
-        각 카테고리의 결과가 나오면 즉시 전달하도록 하는 함수
-        """
-        try:
-            # 우선 상태창 업데이트
-            yield [gr.update(value="카피라이팅 생성 중...")] + [gr.update() for _ in CATEGORIES]
+"""
+[요청사항]
+1) 현재는 한번에 출력되는 형태이므로 병렬 구조로 만들어줌.
+2) 지피티를 각각 항목에 대해 동작.
+3) 결과가 모두 완성된 뒤에 한꺼번에 나오지 말고, '비동기식'으로 바로바로 출력.
+4) asyncio와 aiohttp를 사용하여 비동기 API 호출을 구현하고, 
+   Gradio의 스트리밍 기능을 활용하여 결과를 비동기적으로 업데이트.
+"""
+
+# (기본코드와 동일 기능: 프롬프트 생성 함수 get_category_prompt 유지)
+
+async def call_api_async(session, content, system_message, max_tokens=1000, temperature=0.8, top_p=0.95):
+    """
+    aiohttp를 사용하여 OpenAI API를 비동기로 호출하는 함수
+    """
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {"Authorization": f"Bearer {openai.api_key}"}
+    json_data = {
+        "model": "gpt-4o-mini",
+        "messages": [
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": content},
+        ],
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": top_p,
+    }
+    async with session.post(url, headers=headers, json=json_data) as resp:
+        resp_json = await resp.json()
+        return resp_json["choices"][0]["message"]["content"]
+
+async def fetch_copywriting(session, category, topic):
+    """
+    각 카테고리에 대한 카피라이팅 결과를 비동기로 가져오는 코루틴
+    """
+    prompt = get_category_prompt(category)
+    user_content = f"주제: {topic}"
+    result = await call_api_async(session, user_content, prompt)
+    return category, result
+
+
+def generate_copywriting_stream(topic):
+    """
+    Gradio의 스트리밍 기능을 위해 generator를 리턴하는 함수.
+    카테고리별로 비동기 호출을 하고, 완료되는 순서대로 yield하여 즉시 결과를 보냄.
+    """
+    async def async_gen():
+        # '병렬' 실행을 위해 asyncio.gather 사용
+        async with aiohttp.ClientSession() as session:
+            tasks = []
+            for category in CATEGORIES:
+                tasks.append(fetch_copywriting(session, category, topic))
+            
+            # asyncio.as_completed를 사용하면 '완료되는 순서'대로 결과를 가져올 수 있음
+            for coro in asyncio.as_completed(tasks):
+                try:
+                    category, result = await coro
+                    # 카테고리 결과를 실시간 스트리밍으로 전달
+                    yield f"### [{category}] 결과\n{result}\n\n"
+                except Exception as e:
+                    yield f"### 오류 발생\n{str(e)}\n\n"
+    
+    # Gradio가 stream=True 옵션으로 사용할 수 있는 비동기 제너레이터 반환
+    return async_gen()
 
-            # 비동기로 카피라이팅 생성
-            # 각 카테고리별 결과를 기다리지 않고, 완료되는 순서대로 전달
-            async def async_run():
-                # as_completed로 각 결과가 나올 때마다 받기
-                tasks = {}
-                for category in CATEGORIES:
-                    prompt = get_category_prompt(category)
-                    user_content = f"주제: {topic}"
-                    tasks[category] = asyncio.create_task(
-                        call_api_async(user_content, prompt, 1000, 0.8, 0.95)
-                    )
-                
-                # 카테고리별 결과가 끝나는 순서대로 반환
-                for finished_task in asyncio.as_completed(tasks.values()):
-                    # finished_task가 어떤 카테고리에 해당되는지 찾는다
-                    for cat, tsk in tasks.items():
-                        if tsk == finished_task:
-                            # 해당 카테고리의 결과
-                            try:
-                                result_text = await finished_task
-                            except Exception as e:
-                                result_text = f"오류 발생: {str(e)}"
-                            yield cat, result_text
-                            break
 
-            # 스트리밍 처리
-            # 각 카테고리가 끝날 때마다 yield로 결과 갱신
-            # outputs 순서는 [status] + [카테고리1, 카테고리2, ...]
-            # 따라서 index를 찾아서 부분 업데이트
-            # status(0)번, 카테고리별 1~N
-            current_values = ["카피라이팅 생성 중..."] + ["" for _ in CATEGORIES]
+# 아래는 비동기 버튼(추가) - 기존 코드 수정 없이 새로운 버튼과 출력만 추가
+with gr.Blocks() as async_interface:
+    gr.Markdown("## (비동기 버전) AI 카피라이팅 생성기")
+    with gr.Column():
+        topic_async = gr.Textbox(lines=1, label="주제를 입력하세요(비동기)")
 
-            async for cat, result_text in async_run():
-                # cat의 인덱스를 찾아서 갱신
-                idx = CATEGORIES.index(cat) + 1  # status가 0번이므로 +1
-                current_values[idx] = result_text
-                yield current_values  # 부분 업데이트
+    # 비동기 요청용 버튼
+    async_generate_btn = gr.Button("비동기로 카피라이팅 생성하기")
 
-            # 모든 카테고리가 끝난 후 최종 상태메시지
-            current_values[0] = "카피라이팅 생성이 모두 완료되었습니다."
-            yield current_values
+    # 스트리밍 출력을 받을 Textbox (하나의 텍스트 박스에 순차적으로 표시)
+    async_output = gr.Textbox(label="비동기 결과 스트리밍", lines=20)
 
-        except Exception as e:
-            logger.error(f"Error during copywriting generation: {str(e)}")
-            yield [f"오류 발생: {str(e)}"] + ["" for _ in CATEGORIES]
+    def start_async_generation(topic):
+        # Gradio에서 stream=True 옵션을 사용하기 위해서는 generator(또는 async generator)가 필요
+        return generate_copywriting_stream(topic)
 
-    # 비동기 함수를 Gradio 이벤트에 연결
-    generate_btn.click(
-        fn=validate_and_generate_async,
-        inputs=[topic],
-        outputs=[status] + [output_boxes[category] for category in CATEGORIES],
-        api_name="generate_copy_async"  # 임의의 api_name
+    # 클릭 시, 비동기 제너레이터를 stream=True로 연결
+    async_generate_btn.click(
+        fn=start_async_generation,
+        inputs=topic_async,
+        outputs=async_output,
+        queue=False,    # 비동기 즉시 응답
+        stream=True     # 스���리밍으로 결과 전달
     )
-    ##########################################
-    # 추가된 비동기/병렬 처리용 코드 끝
-    ##########################################
 
-# 인터페이스 실행
-iface.launch()
+# 비동기 인터페이스 실행 (포트 다르게 설정하거나 원하는 대로 사용)
+async_interface.launch(server_name="0.0.0.0", server_port=7861)