feat(customization): prepare func for too large transcripts and too large responses from ai

-

src/handlers.py

@@ -4,10 +4,13 @@ from telegram import Update
 from telegram.ext import ContextTypes
 from telegram.constants import ParseMode
 from .youtube_utils import extract_youtube_urls, extract_video_id, get_transcript
-from .openai_utils import summarize_text
+from .openai_utils import summarize_long_text
 from .db import save_video_summary, check_if_url_exists
 from .config import TRANSCRIPT_LANGUAGES
 
+# Stała dla maksymalnej długości wiadomości Telegram
+MAX_MESSAGE_LENGTH = 4096
+
 logger = logging.getLogger(__name__)
 
 async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -71,7 +74,7 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
         await context.bot.send_chat_action(chat_id=chat_id, action='typing')
         
         # Wygeneruj streszczenie
-        summary = await summarize_text(transcript)
+        summary = await summarize_long_text(transcript)
         if not summary:
             logger.error(f"Nie udało się wygenerować streszczenia dla ID filmu: {video_id}")
             await context.bot.send_message(
@@ -91,11 +94,13 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
                 f"*Link:* {escape_markdown_v2(url)}\n\n"
                 f"*Streszczenie:*\n{escape_markdown_v2(summary)}"
             )
-            await context.bot.send_message(
+            # Użyj funkcji do wysyłania długich wiadomości
+            await send_long_message(
+                context.bot,
                 chat_id=chat_id,
                 text=response_text,
                 parse_mode=ParseMode.MARKDOWN_V2,
-                disable_web_page_preview=True  # Wyłącz podgląd linku w odpowiedzi bota
+                disable_web_page_preview=True
             )
         else:
             logger.error(f"Nie udało się zapisać danych do bazy dla filmu: {title} ({url})")
@@ -113,6 +118,47 @@ def escape_markdown_v2(text: str) -> str:
     escape_chars = r'_*[]()~`>#+-=|{}.!'
     return re.sub(f'([{re.escape(escape_chars)}])', r'\\\1', text)
 
+# Funkcja do dzielenia długich wiadomości
+async def send_long_message(bot, chat_id, text, parse_mode=None, disable_web_page_preview=False):
+    """
+    Wysyła długą wiadomość, dzieląc ją na części, jeśli przekracza limit Telegram.
+    
+    Args:
+        bot: Instancja bota Telegram
+        chat_id: ID czatu
+        text: Tekst do wysłania
+        parse_mode: Tryb parsowania (None, HTML, Markdown, MarkdownV2)
+        disable_web_page_preview: Czy wyłączyć podgląd linków
+    """
+    # Maksymalna długość wiadomości w Telegram to 4096 znaków
+    max_length = MAX_MESSAGE_LENGTH  # 4096 znaków
+    
+    if len(text) <= max_length:
+        # Jeśli wiadomość nie przekracza limitu, wyślij ją normalnie
+        return await bot.send_message(
+            chat_id=chat_id,
+            text=text,
+            parse_mode=parse_mode,
+            disable_web_page_preview=disable_web_page_preview
+        )
+    
+    # Jeśli wiadomość jest za długa, podziel ją
+    parts = []
+    for i in range(0, len(text), max_length):
+        parts.append(text[i:i+max_length])
+    
+    # Wyślij części wiadomości
+    for i, part in enumerate(parts):
+        part_header = f"*Część {i+1}/{len(parts)}*\n\n" if parse_mode == ParseMode.MARKDOWN_V2 else f"Część {i+1}/{len(parts)}\n\n"
+        await bot.send_message(
+            chat_id=chat_id,
+            text=part_header + part,
+            parse_mode=parse_mode,
+            disable_web_page_preview=disable_web_page_preview
+        )
+    
+    return None  # Nie ma sensu zwracać ostatniej wiadomości, bo wysłaliśmy kilka
+
 async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Loguje błędy zgłoszone przez `python-telegram-bot`."""
     logger.error(f"Wyjątek podczas obsługi aktualizacji: {context.error}", exc_info=context.error)

src/openai_utils.py

@@ -1,10 +1,13 @@
 import logging
-from typing import Optional, Tuple, Dict, Any
+from typing import Optional, Tuple, Dict, Any, List
 from openai import AsyncOpenAI  # Używamy AsyncOpenAI dla kompatybilności z asyncio
 from .config import OPENAI_API_KEY, SUMMARY_PROMPT
 
 logger = logging.getLogger(__name__)
 
+# Stała dla maksymalnego rozmiaru pojedynczego zapytania
+MAX_CHUNK_SIZE = 20000
+
 class OpenAIUtilsError(Exception):
     """Bazowa klasa wyjątków dla modułu openai_utils."""
     pass
@@ -92,12 +95,121 @@ async def check_openai_api_status() -> Tuple[bool, Dict[str, Any]]:
         logger.error(f"Błąd podczas sprawdzania statusu API OpenAI: {e}", exc_info=True)
         return False, status_info
 
-async def summarize_text(text: str) -> str:
+async def chunk_text(text: str, max_size: int = MAX_CHUNK_SIZE) -> List[str]:
+    """
+    Dzieli długi tekst na mniejsze fragmenty, starając się zachować granice zdań.
+    
+    Args:
+        text: Tekst do podzielenia
+        max_size: Maksymalny rozmiar pojedynczego fragmentu
+        
+    Returns:
+        Lista fragmentów tekstu
+    """
+    if len(text) <= max_size:
+        return [text]
+    
+    chunks = []
+    start = 0
+    
+    while start < len(text):
+        # Określ koniec fragmentu
+        end = start + max_size
+        
+        if end >= len(text):
+            # Jeśli to ostatni fragment, po prostu użyj reszty tekstu
+            chunks.append(text[start:])
+            break
+        
+        # Znajdź ostatnią kropkę, wykrzyknik lub pytajnik przed lub w miejscu końca
+        last_period = max(
+            text.rfind('. ', start, end),
+            text.rfind('! ', start, end),
+            text.rfind('? ', start, end)
+        )
+        
+        if last_period != -1:
+            # Jeśli znaleziono znak końca zdania, podziel w tym miejscu
+            end = last_period + 2  # +2 aby uwzględnić znak i spację
+        else:
+            # Jeśli nie ma znaku końca zdania, znajdź ostatnią spację
+            last_space = text.rfind(' ', start, end)
+            if last_space != -1:
+                end = last_space + 1
+        
+        chunks.append(text[start:end])
+        start = end
+    
+    logger.info(f"Podzielono tekst o długości {len(text)} znaków na {len(chunks)} fragmentów")
+    return chunks
+
+async def summarize_long_text(text: str) -> str:
+    """
+    Streszcza długi tekst, dzieląc go na mniejsze części, jeśli jest to konieczne.
+    
+    Args:
+        text: Tekst do streszczenia
+        
+    Returns:
+        Streszczenie tekstu
+        
+    Raises:
+        EmptyTextError: Gdy tekst jest pusty
+        APIKeyMissingError: Gdy brak klucza API OpenAI
+        QuotaExceededError: Gdy przekroczono limit zapytań API
+        SummarizationError: Przy innych błędach API OpenAI
+    """
+    if not text:
+        logger.warning("Próba streszczenia pustego tekstu.")
+        raise EmptyTextError("Próba streszczenia pustego tekstu.")
+    
+    # Podziel tekst na fragmenty, jeśli jest zbyt długi
+    chunks = await chunk_text(text)
+    
+    if len(chunks) == 1:
+        # Jeśli tekst nie wymaga podziału, użyj normalnej funkcji streszczania
+        return await summarize_text(chunks[0])
+    
+    # Dla wielu fragmentów, streszczaj każdy osobno, a następnie połącz streszczenia
+    partial_summaries = []
+    
+    for i, chunk in enumerate(chunks):
+        logger.info(f"Streszczanie fragmentu {i+1}/{len(chunks)} (długość: {len(chunk)} znaków)")
+        
+        # Użyj zmodyfikowanego promptu dla fragmentów
+        partial_summary = await summarize_text(
+            chunk, 
+            is_partial=True, 
+            part_num=i+1, 
+            total_parts=len(chunks)
+        )
+        partial_summaries.append(partial_summary)
+    
+    # Połącz wszystkie częściowe streszczenia
+    combined_summary = "\n\n".join(partial_summaries)
+    
+    # Jeśli mamy więcej niż 3 fragmenty, może być potrzebne dodatkowe streszczenie
+    if len(chunks) > 3:
+        logger.info("Tworzenie końcowego streszczenia z połączonych fragmentów")
+        final_summary = await summarize_text(
+            combined_summary, 
+            is_final_summary=True
+        )
+        return final_summary
+    
+    return combined_summary
+
+async def summarize_text(text: str, is_partial: bool = False, part_num: int = 0, 
+                         total_parts: int = 0, is_final_summary: bool = False) -> str:
     """
     Wysyła tekst do API OpenAI w celu streszczenia.
     
     Args:
         text: Tekst do streszczenia
+        is_partial: Czy to część większego tekstu
+        part_num: Numer bieżącej części
+        total_parts: Całkowita liczba części
+        is_final_summary: Czy to końcowe streszczenie z połączonych części
         
     Returns:
         Streszczenie tekstu
@@ -116,7 +228,23 @@ async def summarize_text(text: str) -> str:
         logger.error("Klient OpenAI nie został zainicjalizowany.")
         raise APIKeyMissingError("Klient OpenAI nie został zainicjalizowany. Sprawdź klucz API.")
     
-    prompt = SUMMARY_PROMPT.format(transcript=text)
+    # Wybierz odpowiedni prompt
+    if is_final_summary:
+        prompt = f"""Poniżej znajduje się połączone streszczenie długiego filmu, podzielone na części. 
+        Stwórz z tego spójne, ostateczne streszczenie w języku polskim w formacie markdown.
+        
+        Połączone streszczenia:
+        {text}"""
+    elif is_partial:
+        prompt = f"""Streść poniższy fragment transkryptu filmu z YouTube (część {part_num} z {total_parts}) 
+        w zwięzły sposób w języku polskim. Skup się na głównych tematach i wnioskach.
+        Użyj formatu markdown.
+        
+        Fragment transkryptu (część {part_num}/{total_parts}):
+        {text}"""
+    else:
+        prompt = SUMMARY_PROMPT.format(transcript=text)
+    
     logger.debug(f"Długość tekstu do streszczenia: {len(text)} znaków")
     
     try:
@@ -127,7 +255,7 @@ async def summarize_text(text: str) -> str:
                 {"role": "system", "content": "Jesteś pomocnym asystentem specjalizującym się w streszczaniu transkryptów wideo."},
                 {"role": "user", "content": prompt}
             ],
-            temperature=0.5,  # Niższa temperatura dla bardziej spójnych streszczeń
+            temperature=0.2,  # Niższa temperatura dla bardziej spójnych streszczeń
             max_tokens=5000,  # Ogranicz długość odpowiedzi
         )
         

src/youtube_utils.py

@@ -14,6 +14,7 @@ YOUTUBE_URL_PATTERNS = [
     r'(https?://youtu\.be/[\w-]+)',
     r'(https?://m\.youtube\.com/watch\?v=[\w-]+)',
     r'(https?://(?:www\.)?youtube\.com/shorts/[\w-]+)',
+    r'(https?://(?:www\.)?youtube\.com/live/[\w-]+(?:\?[^&]*)?)',
 ]
 COMPILED_YOUTUBE_REGEX = re.compile('|'.join(YOUTUBE_URL_PATTERNS), re.IGNORECASE)
 
@@ -69,7 +70,8 @@ def extract_video_id(url: str) -> Optional[str]:
         r'youtu\.be/([\w-]+)',  # Skrócony URL
         r'embed/([\w-]+)',  # URL do osadzania
         r'v/([\w-]+)',  # Starszy format
-        r'shorts/([\w-]+)'  # YouTube Shorts
+        r'shorts/([\w-]+)',  # YouTube Shorts
+        r'live/([\w-]+)',  # Transmisje na żywo
     ]
     
     for pattern in patterns: