Update app.py

app.py

@@ -43,110 +43,70 @@ MAX_RETRIES = 3
 class MyClient(discord.Client):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.is_processing = False
         self.session = None
+        self.last_comments = {}
 
     async def on_ready(self):
         logging.info(f'{self.user}로 로그인되었습니다!')
-
-        # web.py 파일 실행
         subprocess.Popen(["python", "web.py"])
         logging.info("Web.py 서버가 시작되었습니다.")
-
-        # aiohttp 클라이언트 세션 생성
         self.session = aiohttp.ClientSession()
-
-        # 봇이 시작될 때 안내 메시지를 전송
-        channel = self.get_channel(SPECIFIC_CHANNEL_ID)
-        if channel:
-            await channel.send("유튜브 비디오 URL을 입력하면, 자막과 댓글을 기반으로 답글을 작성합니다.")
+        self.loop.create_task(self.check_for_new_comments())
+
+    async def check_for_new_comments(self):
+        while True:
+            channel = self.get_channel(SPECIFIC_CHANNEL_ID)
+            if channel:
+                async for message in channel.history(limit=10):
+                    video_id = extract_video_id(message.content)
+                    if video_id:
+                        new_comments = await get_video_comments(video_id)
+                        old_comments = self.last_comments.get(video_id, [])
+                        for comment in new_comments:
+                            if comment not in old_comments:
+                                transcript = await get_best_available_transcript(video_id)
+                                reply = await generate_reply(comment[0], transcript)
+                                await create_thread_and_send_reply(message, video_id, comment, reply, self.session)
+                                self.last_comments[video_id] = new_comments
+            await asyncio.sleep(5)
 
     async def on_message(self, message):
-        if message.author == self.user:
-            return
-        if not self.is_message_in_specific_channel(message):
-            return
-        if self.is_processing:
-            return
-        self.is_processing = True
-        try:
-            video_id = extract_video_id(message.content)
-            if video_id:
-                transcript = await get_best_available_transcript(video_id)
-                comments = await get_video_comments(video_id)
-                if comments and transcript:
-                    replies = await generate_replies(comments, transcript)
-                    await create_thread_and_send_replies(message, video_id, comments, replies, self.session)
-                else:
-                    await message.channel.send("자막이나 댓글을 가져올 수 없습니다.")
-            else:
-                await message.channel.send("유효한 유튜브 비디오 URL을 제공해 주세요.")
-        finally:
-            self.is_processing = False
-
-    def is_message_in_specific_channel(self, message):
-        return message.channel.id == SPECIFIC_CHANNEL_ID or (
-            isinstance(message.channel, discord.Thread) and message.channel.parent_id == SPECIFIC_CHANNEL_ID
-        )
+        pass
 
     async def close(self):
-        # aiohttp 클라이언트 세션 종료
         if self.session:
             await self.session.close()
         await super().close()
 
 def extract_video_id(url):
-    video_id = None
     youtube_regex = (
         r'(https?://)?(www\.)?'
         '(youtube|youtu|youtube-nocookie)\.(com|be)/'
         '(watch\?v=|embed/|v/|.+\?v=)?([^&=%\?]{11})')
-
     match = re.match(youtube_regex, url)
     if match:
-        video_id = match.group(6)
-    logging.debug(f'추출된 비디오 ID: {video_id}')
-    return video_id
+        return match.group(6)
+    return None
 
 async def get_best_available_transcript(video_id):
     try:
         transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['ko'])
+        formatter = TextFormatter()
+        return formatter.format_transcript(transcript)
     except Exception as e:
-        logging.warning(f'한국어 자막 가져오기 오류: {e}')
-        try:
-            transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
-        except Exception as e:
-            logging.warning(f'영어 자막 가져오기 오류: {e}')
-            try:
-                transcripts = YouTubeTranscriptApi.list_transcripts(video_id)
-                transcript = transcripts.find_manually_created_transcript().fetch()
-            except Exception as e:
-                logging.error(f'대체 자막 가져오기 오류: {e}')
-                return None
-
-    formatter = TextFormatter()
-    transcript_text = formatter.format_transcript(transcript)
-    logging.debug(f'가져온 자막: {transcript_text}')
-    return transcript_text
+        logging.error(f"Failed to retrieve transcript: {e}")
+        return None
 
 async def get_video_comments(video_id):
     comments = []
-    response = youtube_service.commentThreads().list(
-        part='snippet',
-        videoId=video_id,
-        maxResults=100  # 최대 100개의 댓글 가져오기
-    ).execute()
-
+    response = youtube_service.commentThreads().list(part='snippet', videoId=video_id, maxResults=100).execute()
     for item in response.get('items', []):
         comment = item['snippet']['topLevelComment']['snippet']['textOriginal']
         comment_id = item['snippet']['topLevelComment']['id']
         comments.append((comment, comment_id))
-    
-    logging.debug(f'가져온 댓글: {comments}')
     return comments
 
-async def generate_replies(comments, transcript):
-    replies = []
+async def generate_reply(comment, transcript):
     system_prompt = """
     너는 유튜브 댓글에 답글을 작성하는 역할이다. 너는 아주 친절하고 쉬운 내용으로 전문적인 글을 '300 토큰 이내'로 작성하여야 한다. 
     영상에서 추출한 '자막'을 기반으로 영상 내용에 기반한 답글을 작성하라.
@@ -155,74 +115,32 @@ async def generate_replies(comments, transcript):
     반드시 한글로 답변하십시오. 
     작성된 글의 마지막에 반드시 인삿말과 OpenFreeAI 라고 자신을 밝혀라.
     """
-    for comment, _ in comments:
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": comment},
-            {"role": "system", "content": f"비디오 자막: {transcript}"}
-        ]
-        loop = asyncio.get_event_loop()
-        response = await loop.run_in_executor(None, lambda: hf_client.chat_completion(
-            messages, max_tokens=250, temperature=0.7, top_p=0.85))
-
-        if response.choices and response.choices[0].message:
-            reply = response.choices[0].message['content'].strip()
-        else:
-            reply = "답글을 생성할 수 없습니다."
-        replies.append(reply)
-    
-    logging.debug(f'생성된 답글: {replies}')
-    return replies
-
-
-
-async def send_webhook_data(session, chunk_data, chunk_number):
-    max_retries = 3  # 최대 재시도 횟수
-    retry_delay = 1  # 재시도 사이의 대기 시간 (초)
-
-    for attempt in range(max_retries):
+    prompt = f"{system_prompt}\n댓글: {comment}\n비디오 자막: {transcript}"
+    response = await hf_client(text=prompt, max_tokens=150)
+    return response['choices'][0]['text']
+
+async def create_thread_and_send_reply(message, video_id, comment, reply, session):
+    thread = await message.channel.create_thread(name=f"{message.author.name}의 댓글 답글", message=message)
+    embed = discord.Embed(description=f"**댓글**: {comment[0]}\n**답글**: {reply}")
+    await thread.send(embed=embed)
+    webhook_data = {"video_id": video_id, "replies": [{"comment": comment[0], "reply": reply, "comment_id": comment[1]}]}
+    await send_webhook_data(session, webhook_data)
+
+async def send_webhook_data(session, data):
+    # 데이터 분할 전송 로직 추가
+    MAX_CHUNK_SIZE = 2000
+    data_json = json.dumps(data)
+    for i in range(0, len(data_json), MAX_CHUNK_SIZE):
+        chunk = data_json[i:i+MAX_CHUNK_SIZE]
         try:
-            async with session.post(WEBHOOK_URL, json=chunk_data) as response:
+            async with session.post(WEBHOOK_URL, json=json.loads(chunk)) as response:
                 if response.status == 200:
-                    logging.info(f"웹훅으로 데이터 전송 성공: 청크 {chunk_number}, 시도 {attempt+1}")
-                    return True  # 성공 시 종료
+                    logging.info("Webhook data sent successfully.")
                 else:
-                    logging.error(f"웹훅으로 데이터 전송 실패: HTTP {response.status}, 청크 {chunk_number}, 시도 {attempt+1}")
+                    logging.error(f"Failed to send webhook data: HTTP {response.status}")
         except aiohttp.ClientError as e:
-            logging.error(f"웹훅 전송 중 HTTP 오류 발생: {e}, 청크 {chunk_number}, 시도 {attempt+1}")
-        except Exception as e:
-            logging.error(f"웹훅 전송 중 알 수 없는 오류 발생: {e}, 청크 {chunk_number}, 시도 {attempt+1}")
-
-        await asyncio.sleep(retry_delay)  # 재시도 전에 1초 대기
-
-    logging.error(f"웹훅 데이터 전송 실패, 모든 재시도 소진: 청크 {chunk_number}")
-    return False  # 재시도 횟수 초과 시 실패로 간주
-
-
-
-async def create_thread_and_send_replies(message, video_id, comments, replies, session):
-    thread = await message.channel.create_thread(name=f"{message.author.name}의 댓글 답글", message=message)
-    webhook_data = {"video_id": video_id, "replies": []}
-
-    for (comment, comment_id), reply in zip(comments, replies):
-        embed = discord.Embed(description=f"**댓글**: {comment}\n**답글**: {reply}")
-        await thread.send(embed=embed)
-
-        # 웹훅 데이터 준비 (comment id 포함)
-        webhook_data["replies"].append({"comment": comment, "reply": reply, "comment_id": comment_id})
-
-    # 데이터를 여러 번 나누어 전송
-    chunk_size = 1  # 전송할 데이터의 개수를 1로 설정하여 각 데이터를 별도로 전송
-    for i in range(0, len(webhook_data["replies"]), chunk_size):
-        chunk = webhook_data["replies"][i:i+chunk_size]
-        chunk_data = {"video_id": video_id, "replies": chunk}
-
-        success = await send_webhook_data(session, chunk_data, i // chunk_size + 1)
-        if not success:
-            logging.error(f"데이터 전송 실패: {i // chunk_size + 1} 번째 청크")
+            logging.error(f"HTTP error occurred while sending webhook data: {e}")
 
 if __name__ == "__main__":
     discord_client = MyClient(intents=intents)
     discord_client.run(os.getenv('DISCORD_TOKEN'))
-
-