Update app.py

app.py

@@ -17,7 +17,6 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import threading
 from moviepy.editor import AudioFileClip, VideoFileClip, concatenate_videoclips
 
-
 # Streamlit UI
 st.set_page_config(
     page_title="Прямая линия с Путиным",
@@ -27,7 +26,7 @@ st.set_page_config(
 )
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
@@ -144,7 +143,7 @@ def generate_text(prompt):
             logger.error(f"API call failed: {str(e)}")
     return '[{"Киселёв":"К сожалению, не удалось расслышать вопрос. Пожалуйста, попробуйте еще раз."}, {"Путин":"Мы работаем над улучшением системы. Спасибо за понимание."}]'
 
-def split_text(text, max_length=300):
+def split_text(text, max_length=800):
     chunks = []
     while len(text) > max_length:
         split_at = text.rfind(' ', 0, max_length)
@@ -178,41 +177,113 @@ def generate_audio(text, speaker_name):
     sf.write(temp_filename, full_audio, sample_rate)
     return temp_filename
 
+def process_single_chunk(chunk_file, speaker):
+    output_filename = f"temp_output_{uuid.uuid4().hex}.wav"
+    try:
+        source_se, _ = se_extractor.get_se(chunk_file, tone_color_converter, vad=True)
+        tone_color_converter.convert(
+            audio_src_path=chunk_file,
+            src_se=source_se,
+            tgt_se=ref_se[speaker],
+            output_path=output_filename,
+        )
+        return output_filename
+    except Exception as e:
+        logger.error(f"Error processing chunk: {str(e)}")
+        return None
+
+def merge_audio_files(files, sample_rate):
+    merged = np.array([])
+    for f in files:
+        audio, _ = sf.read(f)
+        merged = np.concatenate([merged, audio])
+    return merged
+
 def process_line(args):
     idx, speaker, text = args
     final_filename = f"t{idx+1}-{speaker}.wav"
     base_audio = None
-    output_filename = None
-    
+
     try:
         logger.info(f"Processing line {idx+1} for {speaker}")
         base_audio = generate_audio(text, speaker)
-        
+
         if not os.path.exists(base_audio):
             return None
 
-        output_filename = f"output_{uuid.uuid4().hex[:6]}.wav"
-        
-        # Extract source SE and convert
-        source_se, _ = se_extractor.get_se(base_audio, tone_color_converter, vad=True)
-        tone_color_converter.convert(
-            audio_src_path=base_audio,
-            src_se=source_se,
-            tgt_se=ref_se[speaker],
-            output_path=output_filename,
-        )
+        audio_array, sr = sf.read(base_audio)
+        duration = len(audio_array) / sr
+
+        chunks = []
+        if duration > 15:
+            chunk_samples = 15 * sr
+            num_full_chunks = len(audio_array) // chunk_samples
+            remainder_samples = len(audio_array) % chunk_samples
+            remainder_duration = remainder_samples / sr
+
+            chunks = []
+            for i in range(num_full_chunks):
+                start = i * chunk_samples
+                end = start + chunk_samples
+                chunks.append(audio_array[start:end])
+
+            # Handle remainder
+            if remainder_samples > 0:
+                if remainder_duration < 10:
+                    if chunks:
+                        last_chunk = chunks.pop()
+                        merged = np.concatenate([last_chunk, audio_array[num_full_chunks*chunk_samples:]])
+                        chunks.append(merged)
+                    else:
+                        chunks.append(audio_array)
+                else:
+                    chunks.append(audio_array[num_full_chunks*chunk_samples:])
+
+            # Validate chunks durations
+            valid_chunks = []
+            for chunk in chunks:
+                chunk_duration = len(chunk)/sr
+                if chunk_duration >= 10:
+                    valid_chunks.append(chunk)
+                else:
+                    if valid_chunks:
+                        prev = valid_chunks.pop()
+                        merged = np.concatenate([prev, chunk])
+                        valid_chunks.append(merged)
+                    else:
+                        valid_chunks.append(chunk)
+            chunks = valid_chunks
+        else:
+            chunks = [audio_array]
+
+        # Process each chunk
+        converted_files = []
+        for i, chunk in enumerate(chunks):
+            chunk_file = f"temp_chunk_{uuid.uuid4().hex}.wav"
+            sf.write(chunk_file, chunk, sr)
+            chunk_output = process_single_chunk(chunk_file, speaker)
+            if chunk_output:
+                converted_files.append(chunk_output)
+            os.remove(chunk_file)
+
+        if not converted_files:
+            return None
+
+        merged_audio = merge_audio_files(converted_files, sr)
+        sf.write(final_filename, merged_audio, sr)
+
+        # Cleanup converted files
+        for f in converted_files:
+            os.remove(f)
+
+        return final_filename
 
-        if os.path.exists(output_filename):
-            os.rename(output_filename, final_filename)
-            return final_filename
-            
     except Exception as e:
         logger.error(f"Error processing line {idx+1}: {str(e)}")
+        return None
     finally:
-        for f in [base_audio, output_filename]:
-            if f and os.path.exists(f):
-                os.remove(f)
-    return None
+        if base_audio and os.path.exists(base_audio):
+            os.remove(base_audio)
 
 def create_video(audio_files):
     try: