Update app.py

app.py

@@ -1,8 +1,7 @@
 import os
 import gradio as gr
 import openai
-import aiohttp
-import asyncio
+import requests
 import logging
 
 # 로깅 설정
@@ -68,54 +67,35 @@ def get_category_prompt(category):
 - 팔 없는 장애인 화가의 꿈을 이뤄준 첨단 그림 도구
 """
 
-async def call_api_async(session, content, system_message, max_tokens, temperature, top_p):
-    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,
-    }
-    headers = {"Authorization": f"Bearer {openai.api_key}"}
-    async with session.post("https://api.openai.com/v1/chat/completions", json=payload, headers=headers) as response:
-        if response.status != 200:
-            text = await response.text()
-            logger.error(f"API 요청 실패: {response.status}, {text}")
-            raise Exception(f"API 요청 실패: {response.status}")
-        result = await response.json()
-        return result['choices'][0]['message']['content']
-
-async def generate_copywriting_async(categories, topic):
+def call_api_sync(content, system_message, max_tokens, temperature, top_p):
+    response = requests.post(
+        "https://api.openai.com/v1/chat/completions",
+        headers={"Authorization": f"Bearer {openai.api_key}"},
+        json={
+            "model": "gpt-4o-mini",
+            "messages": [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": content},
+            ],
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+        }
+    )
+    result = response.json()
+    return result['choices'][0]['message']['content']
+
+def generate_copywriting(categories, topic):
     max_tokens = 1000
     temperature = 0.8
     top_p = 0.95
-
-    results = {}
-
-    async with aiohttp.ClientSession() as session:
-        tasks = []
-        for category in categories:
-            prompt = get_category_prompt(category)
-            user_content = f"주제: {topic}"
-            task = asyncio.create_task(call_api_async(session, user_content, prompt, max_tokens, temperature, top_p))
-            tasks.append((category, task))
-        
-        # Mapping tasks to categories
-        task_to_category = {task: category for category, task in tasks}
-
-        for task in asyncio.as_completed(task_to_category.keys()):
-            category = task_to_category[task]
-            try:
-                copywriting = await task
-                results[category] = copywriting
-                logger.info(f"Generated {category}: {copywriting}")
-            except Exception as e:
-                logger.error(f"Error generating copywriting for {category}: {str(e)}")
-                results[category] = f"오류 발생: {str(e)}"
     
+    results = {}
+    for category in categories:
+        prompt = get_category_prompt(category)
+        user_content = f"주제: {topic}"
+        copywriting = call_api_sync(user_content, prompt, max_tokens, temperature, top_p)
+        results[category] = copywriting
     return results
 
 # Gradio 인터페이스 부분
@@ -123,7 +103,6 @@ with gr.Blocks() as iface:
     gr.Markdown("# AI 카피라이팅 생성기")
     
     with gr.Column():
-        # 선택 기능 제거
         topic = gr.Textbox(lines=1, label="주제를 입력하세요")
 
     generate_btn = gr.Button("카피라이팅 생성하기")
@@ -136,63 +115,144 @@ with gr.Blocks() as iface:
             output_box = gr.Textbox(label=category, visible=True)
             output_boxes[category] = output_box
 
-    async def validate_and_generate(topic_input):
+    # 기존 동기 함수 (수정/삭제 금지)
+    def validate_and_generate(topic):
         try:
-            # 초기 상태 설정: "카피라이팅 생성 중..." 및 빈 출력 박스
-            current_outputs = ["카피라이팅 생성 중..."] + [""] * len(CATEGORIES)
-            yield [gr.Markdown.update(value=current_outputs[0])] + [gr.Textbox.update(value=o) for o in current_outputs[1:]]
+            results = generate_copywriting(CATEGORIES, topic)
+            logger.debug(f"Generated results: {results}")
+            
+            outputs = []
+            for category in CATEGORIES:
+                if category in results:
+                    outputs.append(gr.update(value=results[category]))
+                else:
+                    outputs.append(gr.update(value=""))
+            
+            return [gr.update(value="카피라이팅 생성이 완료되었습니다.")] + outputs
+        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"]
 
-            # 비동기 카피라이팅 생성
-            async with aiohttp.ClientSession() as session:
-                tasks = []
+    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
+
+    async def validate_and_generate_async(topic):
+        """
+        Gradio에서 스트리밍(yield)을 통해
+        각 카테고리의 결과가 나오면 즉시 전달하도록 하는 함수
+        """
+        try:
+            # 우선 상태창 업데이트
+            yield [gr.update(value="카피라이팅 생성 중...")] + [gr.update() for _ in CATEGORIES]
+
+            # 비동기로 카피라이팅 생성
+            # 각 카테고리별 결과를 기다리지 않고, 완료되는 순서대로 전달
+            async def async_run():
+                # as_completed로 각 결과가 나올 때마다 받기
+                tasks = {}
                 for category in CATEGORIES:
                     prompt = get_category_prompt(category)
-                    user_content = f"주제: {topic_input}"
-                    task = asyncio.create_task(call_api_async(session, user_content, prompt, 1000, 0.8, 0.95))
-                    tasks.append((category, task))
+                    user_content = f"주제: {topic}"
+                    tasks[category] = asyncio.create_task(
+                        call_api_async(user_content, prompt, 1000, 0.8, 0.95)
+                    )
                 
-                # 태스크를 카테고리에 매핑
-                task_to_category = {task: category for category, task in tasks}
-
-                for task in asyncio.as_completed(task_to_category.keys()):
-                    category = task_to_category[task]
-                    try:
-                        copywriting = await task
-                        index = CATEGORIES.index(category) + 1  # +1은 status를 제외하기 위함
-                        current_outputs[index] = copywriting
-                        # 업데이트할 출력 리스트 생성
-                        updates = [gr.Markdown.update(value="카피라이팅 생성 중...")] + [
-                            gr.Textbox.update(value=current_outputs[i + 1]) if i + 1 == index else gr.Textbox.update()
-                            for i in range(len(CATEGORIES))
-                        ]
-                        yield updates
-                    except Exception as e:
-                        logger.error(f"Error generating copywriting for {category}: {str(e)}")
-                        index = CATEGORIES.index(category) + 1
-                        current_outputs[index] = f"오류 발생: {str(e)}"
-                        updates = [gr.Markdown.update(value="카피라이팅 생성 중...")] + [
-                            gr.Textbox.update(value=current_outputs[i + 1]) if i + 1 == index else gr.Textbox.update()
-                            for i in range(len(CATEGORIES))
-                        ]
-                        yield updates
-
-            # 최종 상태 업데이트: "카피라이팅 생성이 완료되었습니다."
-            final_updates = [gr.Markdown.update(value="카피라이팅 생성이 완료되었습니다.")] + [
-                gr.Textbox.update(value=current_outputs[i + 1]) for i in range(len(CATEGORIES))
-            ]
-            yield final_updates
+                # 카테고리별 결과가 끝나는 순서대로 반환
+                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]
+
+            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  # 부분 업데이트
+
+            # 모든 카테고리가 끝난 후 최종 상태메시지
+            current_values[0] = "카피라이팅 생성이 모두 완료되었습니다."
+            yield current_values
 
         except Exception as e:
             logger.error(f"Error during copywriting generation: {str(e)}")
-            error_message = f"오류 발생: {str(e)}"
-            yield [gr.Markdown.update(value=error_message)] + [gr.Textbox.update(value="") for _ in CATEGORIES]
+            yield [f"오류 발생: {str(e)}"] + ["" for _ in CATEGORIES]
 
+    # 비동기 함수를 Gradio 이벤트에 연결
     generate_btn.click(
-        fn=validate_and_generate,
+        fn=validate_and_generate_async,
         inputs=[topic],
         outputs=[status] + [output_boxes[category] for category in CATEGORIES],
-        api_name=None,
+        api_name="generate_copy_async"  # 임의의 api_name
     )
+    ##########################################
+    # 추가된 비동기/병렬 처리용 코드 끝
+    ##########################################
 
 # 인터페이스 실행
 iface.launch()