core/shooting_board.py

import json
import httpx
import asyncio
from typing import Dict, Any, Optional
from utils.logger import SpotMakerLogger

class ShootingBoardGenerator:
    """
    Generator szczegółowego scenariusza spotu reklamowego przy użyciu Hailuo API.
    """
    def __init__(self, api_key: str, logger: SpotMakerLogger):
        self.api_key = api_key
        self.logger = logger
        self.api_url = "https://api.minimaxi.chat/v1/text/chatcompletion_v2"
        self.model = "MiniMax-Text-01"
        self.max_retries = 3
        self.retry_delay = 5  # sekundy

    async def generate(self, concept: str) -> Dict[str, Any]:
        """
        Generuje szczegółowy scenariusz na podstawie koncepcji.
        
        Args:
            concept: Opis koncepcji reklamowej
            
        Returns:
            Dict zawierający scenariusz i tekst lektora
        """
        retry_count = 0
        last_error = None

        while retry_count < self.max_retries:
            try:
                self.logger.log("shooting_board", 
                              f"Próba {retry_count + 1}/{self.max_retries}", 
                              "info")
                
                self.logger.update_progress("shooting_board", 10, "Przygotowuję prompt...")
                prompt = self._prepare_prompt(concept)
                
                self.logger.update_progress("shooting_board", 30, "Wysyłam zapytanie do API...")
                response = await self._call_api(prompt)
                
                self.logger.update_progress("shooting_board", 60, "Przetwarzam odpowiedź...")
                result = self._parse_response(response)
                
                self.logger.update_progress("shooting_board", 100, "Zakończono generowanie scenariusza")
                return result

            except httpx.TimeoutException as e:
                last_error = f"Timeout podczas połączenia z API: {str(e)}"
                self.logger.log("shooting_board", last_error, "warning")
            
            except httpx.HTTPError as e:
                last_error = f"Błąd HTTP podczas połączenia z API: {str(e)}"
                self.logger.log("shooting_board", last_error, "warning")
            
            except Exception as e:
                if "Znaleziono" in str(e) and "ujęć" in str(e):
                    # Błąd parsowania odpowiedzi - nie próbujemy ponownie
                    raise
                last_error = str(e)
                self.logger.log("shooting_board", f"Nieoczekiwany błąd: {last_error}", "warning")

            retry_count += 1
            if retry_count < self.max_retries:
                delay = self.retry_delay * retry_count
                self.logger.log("shooting_board", 
                              f"Ponawiam za {delay}s...", 
                              "info")
                await asyncio.sleep(delay)

        # Jeśli wszystkie próby się nie powiodły
        error_msg = f"Nie udało się wygenerować scenariusza po {self.max_retries} próbach. Ostatni błąd: {last_error}"
        self.logger.log("shooting_board", error_msg, "error")
        raise Exception(error_msg)

    def _prepare_prompt(self, concept: str) -> str:
        """Przygotowuje prompt dla modelu LLM."""
        return f"""Jako doświadczony reżyser reklam, stwórz szczegółowy scenariusz spotu reklamowego 
na podstawie poniższej koncepcji.

Koncepcja:
{concept}

Utwórz DOKŁADNIE 5 ujęć oraz tekst lektora. Format odpowiedzi MUSI być następujący:

Ujęcie 1: [szczegółowy opis pierwszej sceny]
Ujęcie 2: [szczegółowy opis drugiej sceny]
Ujęcie 3: [szczegółowy opis trzeciej sceny]
Ujęcie 4: [szczegółowy opis czwartej sceny]
Ujęcie 5: [szczegółowy opis piątej sceny]

TEKST LEKTORA:
[tekst lektora]

UWAGA: Odpowiedź MUSI zawierać DOKŁADNIE 5 ujęć oznaczonych numerami od 1 do 5. 
Każde ujęcie musi zaczynać się od "Ujęcie X:" gdzie X to numer ujęcia.
Tekst lektora musi być oddzielony nagłówkiem "TEKST LEKTORA:".
Proszę ściśle trzymać się tego formatu."""

    async def _call_api(self, prompt: str) -> Dict[str, Any]:
        """Wysyła zapytanie do Hailuo API."""
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        data = {
            "model": self.model,
            "temperature": 0.2,  # Niższa temperatura dla bardziej spójnych wyników
            "max_tokens": 1000,  # Zwiększamy limit tokenów dla dłuższych opisów
            "messages": [
                {
                    "role": "system",
                    "name": "Director",
                    "content": "Jesteś doświadczonym reżyserem reklam specjalizującym się w tworzeniu kreatywnych i angażujących spotów reklamowych."
                },
                {
                    "role": "user",
                    "name": "user",
                    "content": prompt
                }
            ]
        }

        self.logger.log("shooting_board", 
                       f"Wysyłam request do: {self.api_url}", 
                       "debug")
        
        async with httpx.AsyncClient() as client:
            try:
                response = await client.post(
                    self.api_url,
                    headers=headers,
                    json=data,
                    timeout=30.0
                )
                
                if response.status_code != 200:
                    error_msg = f"API error: {response.status_code} - {response.text}"
                    self.logger.log("shooting_board", error_msg, "error")
                    raise httpx.HTTPError(error_msg)
                    
                return response.json()
                
            except httpx.TimeoutException as e:
                raise httpx.TimeoutException(f"Timeout podczas połączenia z API: {str(e)}")
            except Exception as e:
                raise Exception(f"Błąd podczas wywołania API: {str(e)}")

    def _parse_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
        """Przetwarza odpowiedź z API."""
        try:
            if response.get('base_resp', {}).get('status_code') != 0:
                error_msg = response.get('base_resp', {}).get('status_msg', 'Unknown API error')
                raise ValueError(f"API error: {error_msg}")

            content = response['choices'][0]['message']['content']
            self.logger.log("shooting_board", f"Przetwarzam odpowiedź:\n{content}", "debug")

            # Przygotowanie kontenerów na wyniki
            key_frames = []
            voice_over = ""
            
            # Podziel tekst na linie i znajdź ujęcia oraz tekst lektora
            lines = content.split('\n')
            current_section = None
            current_description = ""
            
            for line in lines:
                line = line.strip()
                if not line:
                    continue
                
                # Bardziej elastyczne wykrywanie ujęć
                if any(marker in line.lower() for marker in ["ujęcie", "scena", "frame", "shot"]):
                    # Jeśli mamy poprzedni opis, zapisz go
                    if current_description and current_section == 'frame':
                        key_frames.append({"description": current_description.strip()})
                    current_section = 'frame'
                    current_description = line.split(":", 1)[1].strip() if ":" in line else ""
                elif any(marker in line.upper() for marker in ["TEKST LEKTORA", "VOICE OVER", "LEKTOR"]):
                    # Jeśli mamy ostatni opis ujęcia, zapisz go
                    if current_description and current_section == 'frame':
                        key_frames.append({"description": current_description.strip()})
                    current_section = 'lektor'
                    current_description = ""
                else:
                    # Dodaj linię do aktualnego opisu
                    if current_section == 'frame':
                        current_description += " " + line
                    elif current_section == 'lektor':
                        voice_over += " " + line.strip('"')

            # Dodaj ostatni opis jeśli istnieje
            if current_description and current_section == 'frame':
                key_frames.append({"description": current_description.strip()})

            # Walidacja wyników z bardziej szczegółowym komunikatem błędu
            if len(key_frames) != 5:
                error_details = f"Znaleziono {len(key_frames)} ujęć zamiast wymaganych 5."
                self.logger.log("shooting_board", error_details, "error")
                self.logger.log("shooting_board", f"Pełna odpowiedź: {content}", "debug")
                raise ValueError(error_details)

            if not voice_over.strip():
                raise ValueError("Brak tekstu dla lektora")

            return {
                "key_frames": key_frames,
                "voice_over": voice_over.strip()
            }
            
        except Exception as e:
            error_msg = f"Błąd przetwarzania odpowiedzi: {str(e)}"
            self.logger.log("shooting_board", error_msg, "error")
            raise Exception(error_msg)

    def get_status(self) -> Dict[str, Any]:
        """Zwraca aktualny status generatora."""
        return {
            'progress': self.logger.get_module_progress("shooting_board"),
            'status': self.logger.get_module_status("shooting_board")
        }