Как разбить 30 000 слов на таймкоды для субтитров

def add_timecodes_to_chunks(text_segments, timecodes):
    """
    Добавляет временные метки к текстовым сегментам
    """
    chunks_with_timecodes = []
    for segment, start_time, end_time in zip(text_segments, timecodes):
        chunks_with_timecodes.append({
            'text': segment,
            'start_time': start_time,
            'end_time': end_time,
            'duration': end_time - start_time
        })
    return chunks_with_timecodes

def process_long_text_continuation(text, model, max_tokens=8000):
    """
    Обрабатывает длинный текст с использованием техники продолжения
    """
    chunks = semantic_chunking_with_overlap(text, overlap_tokens=200)
    results = []
    
    for i, chunk in enumerate(chunks):
        if i == 0:
            # Первый чанк обрабатывается полностью
            prompt = f"Обработай следующий текст и выдай таймкоды:\n{chunk}"
        else:
            # Последующие чанки включают контекст из предыдущего
            prev_context = chunks[i-1][-500:]  # Последние 500 символов
            prompt = f"Продолжи обработку текста. Предыдущий контекст:\n{prev_context}\n\nНовый фрагмент:\n{chunk}"
        
        result = model.generate(prompt, max_tokens=max_tokens)
        results.append(result)
    
    return results

import re
from datetime import timedelta

def timecode_to_seconds(timecode):
    """Конвертирует таймкод (HH:MM:SS,ms) в секунды"""
    hours, minutes, seconds_ms = timecode.split(':')
    seconds, milliseconds = seconds_ms.split(',')
    return (int(hours) * 3600 + int(minutes) * 60 + 
            int(seconds) + int(milliseconds) / 1000)

def seconds_to_timecode(seconds):
    """Конвертирует секунды в таймкод (HH:MM:SS,ms)"""
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = seconds % 60
    return f"{hours:02d}:{minutes:02d}:{secs:06.3f}".replace('.', ',')

def process_large_subtitle_text(text_30000_words, model):
    """
    Основная функция обработки 30 000 слов для генерации таймкодов
    """
    # Шаг 1: Предварительная сегментация по естественным паузам
    segments = natural_speech_segmentation(text_30000_words)
    
    # Шаг 2: Определение примерных длительностей
    word_count_per_segment = [len(seg.split()) for seg in segments]
    estimated_durations = [words * 0.5 for words in word_count_per_segment]  # ~0.5 сек на слово
    
    # Шаг 3: Семантический чанкинг с перекрытием
    semantic_chunks = semantic_chunking_with_overlap(
        text_30000_words, 
        chunk_size=300, 
        overlap_tokens=60
    )
    
    # Шаг 4: Пакетная обработка с сохранением контекста
    all_timecodes = []
    current_time = 0
    
    for i, chunk in enumerate(semantic_chunks):
        # Добавление контекста из предыдущего чанка
        if i > 0:
            context = semantic_chunks[i-1][-200:]
            enhanced_prompt = f"Контекст: {context}\n\nТекущий текст: {chunk}"
        else:
            enhanced_prompt = chunk
        
        # Генерация таймкодов для чанка
        timecode_result = model.generate_timecodes(enhanced_prompt)
        
        # Конвертация и добавление к общему списку
        chunk_timecodes = [
            (seconds_to_timecode(current_time + offset), 
             seconds_to_timecode(current_time + offset + duration))
            for offset, duration in timecode_result
        ]
        
        all_timecodes.extend(chunk_timecodes)
        current_time += sum(duration for _, duration in timecode_result)
    
    return all_timecodes

def natural_speech_segmentation(text):
    """
    Сегментация текста по естественным паузам в речи
    """
    # Паттерны для естественных пауз
    pause_patterns = [
        r'[.!?]\s+',  # Точка, восклицательный знак, вопросительный знак + пробел
        r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?|\!)\s',  # Более сложный паттерн
        r'\n\s*\n',  # Пустые строки
        r'–\s+',  # Тире
    ]
    
    segments = []
    current_segment = ""
    
    for sentence in re.split('|'.join(pause_patterns), text):
        if len(current_segment) + len(sentence) < 500:  # Максимальная доля сегмента
            current_segment += sentence + " "
        else:
            segments.append(current_segment.strip())
            current_segment = sentence + " "
    
    if current_segment:
        segments.append(current_segment.strip())
    
    return segments

def robust_processing_with_recovery(text, model, max_retries=3):
    """
    Обработка с автоматическим восстановлением при ошибках
    """
    try:
        # Попытка полной обработки
        result = process_large_subtitle_text(text, model)
        return result
    except Exception as e:
        if max_retries > 0:
            print(f"Ошибка: {e}. Попытка восстановления...")
            
            # Разбиваем на более мелкие чанки
            smaller_chunks = aggressive_chunking(text, chunk_size=150)
            
            results = []
            for chunk in smaller_chunks:
                try:
                    chunk_result = model.generate_timecodes(chunk)
                    results.extend(chunk_result)
                except Exception as chunk_error:
                    print(f"Ошибка обработки чанка: {chunk_error}")
                    continue
            
            # Слияние результатов с сохранением таймкодов
            merged_results = merge_timecoded_results(results)
            return merged_results
        else:
            raise e

class ContextCache:
    def __init__(self, max_cache_size=5):
        self.context_cache = []
        self.max_cache_size = max_cache_size
    
    def add_context(self, context):
        if len(self.context_cache) >= self.max_cache_size:
            self.context_cache.pop(0)
        self.context_cache.append(context)
    
    def get_relevant_context(self, current_text):
        # Поиск наиболее релевантного контента
        relevant_contexts = []
        for cached_context in self.context_cache:
            similarity = calculate_similarity(current_text, cached_context)
            if similarity > 0.7:  # Порог релевантности
                relevant_contexts.append(cached_context)
        return ' '.join(relevant_contexts[-2:])  # Последние 2 релевантных контекста

from langchain.text_splitter import RecursiveCharacterTextSplitter, SemanticChunker

# Рекурсивный сплиттер с настраиваемыми параметрами
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=300,
    chunk_overlap=60,
    length_function=len,
)

# Семантический чанкинг
semantic_splitter = SemanticChunker(
    embedding_model,
    chunk_size=300,
    breakpoint_threshold_type="percentile",
    breakpoint_threshold_amount=95,
)

ffmpeg -i input_audio.wav -acodec pcm_s16le -ar 16000 -ac 1 processed_audio.wav

def create_subtitle_pipeline(input_text, output_file):
    """
    Полный пайплайн генерации субтитров с таймкодами
    """
    # Этап 1: Предварительная обработка
    cleaned_text = preprocess_text(input_text)
    
    # Этап 2: Определение сегментов
    segments = determine_speech_segments(cleaned_text)
    
    # Этап 3: Семантический чанкинг
    chunks = apply_semantic_chunking(segments)
    
    # Этап 4: Генерация таймкодов
    timecoded_segments = generate_timecodes(chunks)
    
    # Этап 5: Форматирование вывода
    formatted_subtitles = format_srt(timecoded_segments)
    
    # Этап 6: Сохранение результата
    save_subtitle_file(formatted_subtitles, output_file)
    
    return output_file