Update app.py

app.py

@@ -8,13 +8,14 @@ import os
 import uuid
 import logging
 import numpy as np
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import threading
 from moviepy.editor import AudioFileClip, VideoFileClip, concatenate_videoclips
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
 
 # Initialize G4F client
 client = Client()
@@ -46,28 +47,46 @@ def get_task(prompt):
 def validate_response(response):
     try:
         data = json.loads(response)
-        if isinstance(data, list) and all(isinstance(item, dict) and len(item) == 1 for item in data):
-            return True
-    except json.JSONDecodeError:
-        pass
-    return False
+        if not isinstance(data, list):
+            logger.warning("Invalid response: Root element is not a list")
+            return False
+        for idx, item in enumerate(data):
+            if not isinstance(item, dict):
+                logger.warning(f"Invalid item #{idx+1}: Not a dictionary")
+                return False
+            if len(item) != 1:
+                logger.warning(f"Invalid item #{idx+1}: Contains {len(item)} keys instead of 1")
+                return False
+            key = next(iter(item.keys()))
+            if key not in ["Киселёв", "Путин"]:
+                logger.warning(f"Invalid item #{idx+1}: Unexpected speaker '{key}'")
+                return False
+        return True
+    except json.JSONDecodeError as e:
+        logger.warning(f"JSON decode error: {str(e)}")
+        return False
 
 def generate_text(prompt):
+    logger.info(f"Generating text for prompt: '{prompt}'")
     max_retries = 4
     for attempt in range(max_retries):
-        logger.info(f"Generating response for prompt: {prompt} (attempt {attempt+1})")
-        response = client.chat.completions.create(
-            model="llama-3.3-70b",
-            messages=[{"role": "user", "content": get_task(prompt)}],
-            web_search=False
-        )
-        response_text = response.choices[0].message.content
-        logger.info(f"Generated response: {response_text}")
+        try:
+            response = client.chat.completions.create(
+                model="llama-3.3-70b",
+                messages=[{"role": "user", "content": get_task(prompt)}],
+                web_search=False
+            )
+            response_text = response.choices[0].message.content
+            logger.debug(f"Raw API response: {response_text}")
+
+            if validate_response(response_text):
+                logger.info(f"Successfully validated response (attempt {attempt+1})")
+                return response_text
+            logger.warning(f"Validation failed (attempt {attempt+1})")
+
+        except Exception as e:
+            logger.error(f"API call failed: {str(e)}")
         
-        if validate_response(response_text):
-            return response_text
-        logger.warning("Invalid response format, retrying...")
-    
     logger.error("Failed to generate valid response after 4 attempts")
     return '[{"Киселёв":"К сожалению, не удалось расслышать вопрос. Пожалуйста, попробуйте еще раз."}, {"Путин":"Мы работаем над улучшением системы. Спасибо за понимание."}]'
 
@@ -81,20 +100,22 @@ def split_text(text, max_length=800):
         chunks.append(text[:split_at])
         text = text[split_at:].lstrip()
     chunks.append(text)
+    logger.debug(f"Split text into {len(chunks)} chunks")
     return chunks
 
 def generate_audio(text, speaker_name):
     """Generate audio with thread-safe splitting and synthesis"""
-    logger.info(f"Generating audio for {speaker_name} ({len(text)} chars)")
+    logger.info(f"Generating audio for {speaker_name} ({len(text)} characters)")
     
     # Switch between speakers
     silero_speaker = 'aidar' if speaker_name == 'Киселёв' else 'baya'
-    logger.debug(f"Using Silero speaker: {silero_speaker} for {speaker_name}")
+    logger.debug(f"Using Silero speaker: {silero_speaker}")
     
     chunks = split_text(text)
     audio_arrays = []
     
-    for chunk in chunks:
+    for idx, chunk in enumerate(chunks, 1):
+        logger.debug(f"Processing chunk {idx}/{len(chunks)}")
         with tts_lock:  # Ensure thread-safe TTS operations
             audio = model.apply_tts(
                 ssml_text=f"<speak>{chunk}</speak>",
@@ -108,6 +129,7 @@ def generate_audio(text, speaker_name):
     full_audio = np.concatenate(audio_arrays)
     temp_filename = f"temp_{uuid.uuid4().hex}.wav"
     sf.write(temp_filename, full_audio, sample_rate)
+    logger.debug(f"Temporary audio saved: {temp_filename}")
     return temp_filename
 
 def process_line(args):
@@ -160,13 +182,14 @@ def process_line(args):
 
 def create_video(audio_files):
     """Create final video from processed audio files"""
-    logger.info("Starting video creation process")
+    logger.info(f"⏳ Starting video creation with {len(audio_files)} audio files")
     
     try:
         # Sort audio files by their numerical index
         audio_files.sort(key=lambda x: int(x.split('t')[1].split('-')[0]))
         clips = []
 
+        logger.info("Processing audio-GIF pairs:")
         for audio_file in audio_files:
             speaker = audio_file.split('-')[1].split('.')[0]
             gif_file = GIF_MAPPING.get(speaker)
@@ -175,21 +198,23 @@ def create_video(audio_files):
                 logger.error(f"Missing GIF file for {speaker}")
                 continue
 
-            logger.info(f"Processing {audio_file} with {gif_file}")
-            
             audio_clip = AudioFileClip(audio_file)
+            logger.info(f"🔊 {os.path.basename(audio_file)} ({audio_clip.duration:.1f}s)")
+            
             gif_clip = VideoFileClip(gif_file).loop(duration=audio_clip.duration)
             gif_clip = gif_clip.set_audio(audio_clip)
             clips.append(gif_clip)
+            logger.debug(f"Processed {speaker} segment")
 
         if not clips:
             raise ValueError("No valid video clips created")
 
         final_video = concatenate_videoclips(clips)
         video_filename = f"output_{uuid.uuid4().hex[:8]}.mp4"
-        final_video.write_videofile(video_filename, codec='libx264', audio_codec='aac', logger='bar' if logger.level == logging.DEBUG else None)
+        logger.info(f"🎬 Concatenating {len(clips)} clips (total: {final_video.duration:.1f}s)")
         
-        logger.info(f"Successfully created video: {video_filename}")
+        final_video.write_videofile(video_filename, codec='libx264', audio_codec='aac')
+        logger.info(f"✅ Successfully created video: {video_filename}")
         return video_filename
 
     except Exception as e:
@@ -198,13 +223,15 @@ def create_video(audio_files):
 
 def process_prompt(prompt):
     """Main processing pipeline with parallel execution"""
-    logger.info(f"Starting processing for prompt: {prompt}")
+    logger.info(f"🚀 Starting processing for prompt: '{prompt}'")
     
     try:
         # Generate script
         script = generate_text(prompt)
+        logger.debug(f"Raw script data: {script}")
         script_data = json.loads(script)
-        
+        logger.info(f"📝 Generated script with {len(script_data)} lines")
+
         # Prepare tasks for parallel processing
         tasks = [(idx, speaker, text) 
                  for idx, item in enumerate(script_data) 
@@ -214,21 +241,26 @@ def process_prompt(prompt):
         audio_files = []
         with ThreadPoolExecutor(max_workers=4) as executor:
             futures = [executor.submit(process_line, task) for task in tasks]
-            for future in futures:
+            total_tasks = len(futures)
+            logger.info(f"📦 Processing {total_tasks} audio segments in parallel")
+            
+            for i, future in enumerate(as_completed(futures), 1):
                 result = future.result()
                 if result:
                     audio_files.append(result)
-        
+                    remaining = total_tasks - i
+                    logger.info(f"🔧 Processed {os.path.basename(result)} ({i}/{total_tasks}, {remaining} remaining)")
+                else:
+                    logger.warning(f"⚠️ Failed to process task {i}/{total_tasks}")
+
         # Create final video
         if not audio_files:
             raise ValueError("No audio files generated")
         
-        video_filename = create_video(audio_files)
-        
-        return video_filename
+        return create_video(audio_files)
         
     except Exception as e:
-        logger.error(f"Processing failed: {str(e)}", exc_info=True)
+        logger.error(f"❌ Processing failed: {str(e)}", exc_info=True)
         return None
     finally:
         # Cleanup audio files after video creation