Deploy complete ChatterboxTTS system with utils, tools, and wrapper modules

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

modules/asr_manager.py

@@ -0,0 +1,233 @@
+"""
+ASR Manager Module
+Centralized ASR model loading with adaptive GPU/CPU fallback and real-time VRAM monitoring
+"""
+
+import torch
+import logging
+from pathlib import Path
+from config.config import DEFAULT_ASR_MODEL, ASR_MODEL_VRAM_MB, ASR_MODEL_RAM_MB
+
+def get_real_time_vram_status():
+    """Get current GPU memory usage in real-time"""
+    try:
+        if torch.cuda.is_available():
+            gpu_count = torch.cuda.device_count()
+            if gpu_count > 0:
+                # Use first GPU
+                total_vram = torch.cuda.get_device_properties(0).total_memory
+                allocated_vram = torch.cuda.memory_allocated(0)
+                reserved_vram = torch.cuda.memory_reserved(0)
+                available_vram = total_vram - allocated_vram
+                
+                return {
+                    'total_mb': total_vram // 1024 // 1024,
+                    'allocated_mb': allocated_vram // 1024 // 1024,
+                    'reserved_mb': reserved_vram // 1024 // 1024,
+                    'available_mb': available_vram // 1024 // 1024,
+                    'has_gpu': True
+                }
+    except Exception as e:
+        logging.warning(f"Failed to get real-time VRAM status: {e}")
+    
+    return {
+        'total_mb': 0,
+        'allocated_mb': 0, 
+        'reserved_mb': 0,
+        'available_mb': 0,
+        'has_gpu': False
+    }
+
+def calculate_available_vram_for_asr(safety_buffer_mb=500):
+    """Calculate VRAM available for ASR with safety buffer"""
+    vram_status = get_real_time_vram_status()
+    
+    if not vram_status['has_gpu']:
+        return 0
+    
+    # Available VRAM minus safety buffer for stability
+    available_with_buffer = max(0, vram_status['available_mb'] - safety_buffer_mb)
+    
+    return available_with_buffer
+
+def can_model_fit_gpu(model_name, available_vram_mb):
+    """Check if a specific ASR model can fit in available VRAM"""
+    required_vram = ASR_MODEL_VRAM_MB.get(model_name, 0)
+    return available_vram_mb >= required_vram
+
+def try_load_model_with_fallback(model_name, primary_device, fallback_device="cpu"):
+    """Try to load model on primary device, fallback to secondary if it fails"""
+    import whisper
+    
+    # Convert device names for whisper compatibility
+    def convert_device_name(device):
+        if device.lower() == "gpu":
+            return "cuda"
+        return device.lower()
+    
+    primary_device_whisper = convert_device_name(primary_device)
+    fallback_device_whisper = convert_device_name(fallback_device)
+    
+    try:
+        print(f"🎯 Attempting to load {model_name} on {primary_device.upper()}")
+        model = whisper.load_model(model_name, device=primary_device_whisper)
+        print(f"✅ Successfully loaded {model_name} on {primary_device.upper()}")
+        return model, primary_device
+        
+    except Exception as e:
+        print(f"⚠️ {model_name} failed on {primary_device} ({str(e)[:50]}...)")
+        
+        if fallback_device_whisper != primary_device_whisper:
+            try:
+                print(f"🔄 Trying {model_name} on {fallback_device.upper()}")
+                model = whisper.load_model(model_name, device=fallback_device_whisper)
+                print(f"✅ Successfully loaded {model_name} on {fallback_device.upper()}")
+                return model, fallback_device
+                
+            except Exception as fallback_e:
+                print(f"❌ {model_name} also failed on {fallback_device} ({str(fallback_e)[:50]}...)")
+        
+        # Both failed
+        raise Exception(f"Model {model_name} failed on both {primary_device} and {fallback_device}")
+
+def load_asr_model_adaptive(asr_config=None):
+    """
+    Adaptive ASR model loading with real-time VRAM checking and intelligent fallback
+    
+    Args:
+        asr_config: ASR configuration dict from interfaces (None for GUI fallback)
+        
+    Returns:
+        tuple: (asr_model, actual_device_used) or (None, None) if all loading fails
+    """
+    print(f"🔍 Starting adaptive ASR model loading...")
+    
+    # Get current VRAM status
+    vram_status = get_real_time_vram_status()
+    available_vram = calculate_available_vram_for_asr()
+    
+    print(f"🖥️ Real-time VRAM status:")
+    print(f"   Total: {vram_status['total_mb']:,}MB")
+    print(f"   Allocated: {vram_status['allocated_mb']:,}MB") 
+    print(f"   Available for ASR: {available_vram:,}MB (with 500MB safety buffer)")
+    
+    # Determine what models to try based on config
+    if asr_config and asr_config.get('enabled') and 'primary_model' in asr_config:
+        # Intelligent selection from CLI/Gradio
+        primary_model = asr_config['primary_model']
+        primary_device = asr_config['primary_device']
+        fallback_model = asr_config['fallback_model'] 
+        fallback_device = asr_config['fallback_device']
+        
+        print(f"🧠 Using intelligent ASR config:")
+        print(f"   Primary: {primary_model} on {primary_device.upper()}")
+        print(f"   Fallback: {fallback_model} on {fallback_device.upper()}")
+        
+        # Real-time VRAM check for primary model
+        if primary_device.lower() == 'gpu':
+            if not vram_status['has_gpu']:
+                print(f"⚠️ No GPU available, forcing CPU mode")
+                primary_device = 'cpu'
+            elif not can_model_fit_gpu(primary_model, available_vram):
+                required = ASR_MODEL_VRAM_MB.get(primary_model, 0)
+                print(f"⚠️ Insufficient VRAM for {primary_model} (need {required}MB, have {available_vram}MB)")
+                print(f"🔄 Switching primary to CPU")
+                primary_device = 'cpu'
+        
+        # Try primary model
+        try:
+            return try_load_model_with_fallback(primary_model, primary_device, primary_device)
+        except:
+            # Primary failed, try fallback model
+            print(f"🔄 Primary model failed, trying fallback configuration...")
+            
+            # Real-time VRAM check for fallback model  
+            if fallback_device.lower() == 'gpu':
+                if not vram_status['has_gpu']:
+                    print(f"⚠️ No GPU available for fallback, using CPU")
+                    fallback_device = 'cpu'
+                elif not can_model_fit_gpu(fallback_model, available_vram):
+                    required = ASR_MODEL_VRAM_MB.get(fallback_model, 0)
+                    print(f"⚠️ Insufficient VRAM for fallback {fallback_model} (need {required}MB, have {available_vram}MB)")
+                    fallback_device = 'cpu'
+            
+            try:
+                return try_load_model_with_fallback(fallback_model, fallback_device, 'cpu')
+            except:
+                print(f"❌ Both configured models failed!")
+    
+    else:
+        # Fallback mode for GUI or missing config
+        print(f"🔧 Using fallback mode: {DEFAULT_ASR_MODEL}")
+    
+    # Last resort: try default model with adaptive device selection
+    print(f"🆘 Last resort: trying {DEFAULT_ASR_MODEL} with adaptive device selection")
+    
+    # Choose device based on real-time VRAM availability
+    if vram_status['has_gpu'] and can_model_fit_gpu(DEFAULT_ASR_MODEL, available_vram):
+        device = 'cuda'  # Use cuda directly for whisper
+        device_display = 'GPU'
+        print(f"✅ Using GPU for {DEFAULT_ASR_MODEL}")
+    else:
+        device = 'cpu'  
+        device_display = 'CPU'
+        print(f"🔄 Using CPU for {DEFAULT_ASR_MODEL}")
+    
+    try:
+        import whisper
+        model = whisper.load_model(DEFAULT_ASR_MODEL, device=device)
+        print(f"✅ Successfully loaded {DEFAULT_ASR_MODEL} on {device_display}")
+        return model, device_display.lower()
+    except Exception as e:
+        print(f"❌ Critical failure: Could not load {DEFAULT_ASR_MODEL} on {device}: {e}")
+        
+        # Ultimate fallback to CPU if GPU failed
+        if device == 'cuda':
+            try:
+                print(f"🆘 Ultimate fallback: {DEFAULT_ASR_MODEL} on CPU")
+                model = whisper.load_model(DEFAULT_ASR_MODEL, device='cpu')
+                print(f"✅ Successfully loaded {DEFAULT_ASR_MODEL} on CPU")
+                return model, 'cpu'
+            except Exception as cpu_e:
+                print(f"💀 Complete failure: {cpu_e}")
+        
+        return None, None
+
+def cleanup_asr_model(asr_model):
+    """Clean up ASR model to free memory"""
+    if asr_model is not None:
+        try:
+            del asr_model
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            print(f"🧹 ASR model cleaned up")
+        except Exception as e:
+            logging.warning(f"Failed to cleanup ASR model: {e}")
+
+def get_asr_memory_info():
+    """Get memory information for ASR debugging"""
+    vram_status = get_real_time_vram_status()
+    available_vram = calculate_available_vram_for_asr()
+    
+    info = {
+        'vram_total_mb': vram_status['total_mb'],
+        'vram_allocated_mb': vram_status['allocated_mb'],
+        'vram_available_for_asr_mb': available_vram,
+        'has_gpu': vram_status['has_gpu']
+    }
+    
+    return info
+
+if __name__ == "__main__":
+    # Test the adaptive loading
+    print("Testing ASR Manager...")
+    info = get_asr_memory_info()
+    print(f"Memory info: {info}")
+    
+    # Test adaptive loading
+    model, device = load_asr_model_adaptive()
+    if model:
+        print(f"Test successful: Model loaded on {device}")
+        cleanup_asr_model(model)
+    else:
+        print("Test failed: No model loaded")

modules/system_detector.py

@@ -0,0 +1,231 @@
+"""
+System Resource Detection Module
+Detects VRAM, RAM, CPU cores and recommends appropriate ASR models
+"""
+
+import psutil
+import torch
+import os
+import sys
+from pathlib import Path
+
+# Add project root to path for imports
+if __name__ == "__main__":
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from config.config import ASR_MODEL_VRAM_MB, ASR_MODEL_RAM_MB
+
+def get_gpu_memory():
+    """Get total and available GPU memory in MB"""
+    try:
+        if torch.cuda.is_available():
+            gpu_count = torch.cuda.device_count()
+            if gpu_count > 0:
+                # Use first GPU
+                total_vram = torch.cuda.get_device_properties(0).total_memory
+                allocated_vram = torch.cuda.memory_allocated(0)
+                available_vram = total_vram - allocated_vram
+                
+                return {
+                    'total_mb': total_vram // 1024 // 1024,
+                    'available_mb': available_vram // 1024 // 1024,
+                    'allocated_mb': allocated_vram // 1024 // 1024
+                }
+    except:
+        pass
+    
+    return {'total_mb': 0, 'available_mb': 0, 'allocated_mb': 0}
+
+def get_system_memory():
+    """Get total and available system RAM in MB"""
+    try:
+        memory = psutil.virtual_memory()
+        return {
+            'total_mb': memory.total // 1024 // 1024,
+            'available_mb': memory.available // 1024 // 1024,
+            'used_mb': memory.used // 1024 // 1024
+        }
+    except:
+        return {'total_mb': 0, 'available_mb': 0, 'used_mb': 0}
+
+def get_cpu_cores():
+    """Get number of CPU cores"""
+    try:
+        return psutil.cpu_count(logical=False) or psutil.cpu_count()
+    except:
+        return 1
+
+def estimate_tts_vram_usage():
+    """Estimate VRAM usage by ChatterboxTTS (updated based on real usage)"""
+    return 5500  # 5.5GB in MB (was 7GB, adjusted based on actual 3.5GB usage + buffer)
+
+def get_system_profile():
+    """Get complete system resource profile"""
+    gpu_info = get_gpu_memory()
+    ram_info = get_system_memory()
+    cpu_cores = get_cpu_cores()
+    
+    # Estimate available resources after TTS loading
+    tts_vram_estimate = estimate_tts_vram_usage()
+    available_vram_after_tts = max(0, gpu_info['available_mb'] - tts_vram_estimate)
+    
+    return {
+        'gpu': gpu_info,
+        'ram': ram_info,
+        'cpu_cores': cpu_cores,
+        'available_vram_after_tts': available_vram_after_tts,
+        'has_gpu': gpu_info['total_mb'] > 0
+    }
+
+def categorize_system(profile):
+    """Categorize system capabilities"""
+    gpu_total = profile['gpu']['total_mb']
+    ram_total = profile['ram']['total_mb']
+    cpu_cores = profile['cpu_cores']
+    
+    # VRAM categories
+    if gpu_total < 4000:
+        vram_category = "low"
+    elif gpu_total <= 12000:
+        vram_category = "medium"
+    else:
+        vram_category = "high"
+    
+    # RAM categories  
+    if ram_total < 16000:
+        ram_category = "low"
+    elif ram_total <= 64000:
+        ram_category = "medium"
+    else:
+        ram_category = "high"
+    
+    # CPU categories
+    if cpu_cores < 6:
+        cpu_category = "low"
+    elif cpu_cores <= 16:
+        cpu_category = "medium"
+    else:
+        cpu_category = "high"
+    
+    return {
+        'vram': vram_category,
+        'ram': ram_category,
+        'cpu': cpu_category
+    }
+
+def get_safe_asr_models(profile):
+    """Get ASR models that can safely run on GPU with available VRAM"""
+    available_vram = profile['available_vram_after_tts']
+    safe_models = []
+    
+    for model, vram_req in ASR_MODEL_VRAM_MB.items():
+        if vram_req <= available_vram:
+            safe_models.append(model)
+    
+    return safe_models
+
+def get_safe_cpu_models(profile):
+    """Get ASR models that can safely run on CPU with available RAM"""
+    available_ram = profile['ram']['available_mb']
+    safe_models = []
+    
+    for model, ram_req in ASR_MODEL_RAM_MB.items():
+        if ram_req <= available_ram:
+            safe_models.append(model)
+    
+    return safe_models
+
+def recommend_asr_models(profile):
+    """Recommend Safe/Moderate/Insane ASR model configurations"""
+    categories = categorize_system(profile)
+    safe_gpu_models = get_safe_asr_models(profile)
+    safe_cpu_models = get_safe_cpu_models(profile)
+    
+    recommendations = {}
+    
+    # Model priority order (best to worst)
+    model_priority = ["large-v3", "large", "large-v2", "medium", "small", "base", "tiny"]
+    
+    # Safe: Conservative choice
+    safe_gpu = None
+    safe_cpu = None
+    
+    for model in reversed(model_priority):  # Start from smallest
+        if model in safe_gpu_models and not safe_gpu:
+            safe_gpu = model
+        if model in safe_cpu_models and not safe_cpu:
+            safe_cpu = model
+        if safe_gpu and safe_cpu:
+            break
+    
+    # Moderate: Balanced choice  
+    moderate_gpu = None
+    moderate_cpu = None
+    
+    # Try to get a model 1-2 steps up from safe
+    safe_idx = model_priority.index(safe_gpu) if safe_gpu else len(model_priority)
+    moderate_idx = max(0, safe_idx - 2)
+    
+    for i in range(moderate_idx, len(model_priority)):
+        model = model_priority[i]
+        if model in safe_gpu_models and not moderate_gpu:
+            moderate_gpu = model
+        if model in safe_cpu_models and not moderate_cpu:
+            moderate_cpu = model
+        if moderate_gpu and moderate_cpu:
+            break
+    
+    # Insane: Push the limits (best available models)
+    insane_gpu = None
+    insane_cpu = None
+    
+    # Get the best (largest) models that are safe
+    for model in model_priority:  # Start from best
+        if model in safe_gpu_models and not insane_gpu:
+            insane_gpu = model
+        if model in safe_cpu_models and not insane_cpu:
+            insane_cpu = model
+        if insane_gpu and insane_cpu:
+            break
+    
+    # Build recommendations
+    recommendations['safe'] = {
+        'primary': {'model': safe_gpu or safe_cpu, 'device': 'gpu' if safe_gpu else 'cpu'},
+        'fallback': {'model': safe_cpu, 'device': 'cpu'}
+    }
+    
+    recommendations['moderate'] = {
+        'primary': {'model': moderate_gpu or moderate_cpu, 'device': 'gpu' if moderate_gpu else 'cpu'},
+        'fallback': {'model': moderate_cpu, 'device': 'cpu'}
+    }
+    
+    recommendations['insane'] = {
+        'primary': {'model': insane_gpu or insane_cpu, 'device': 'gpu' if insane_gpu else 'cpu'},
+        'fallback': {'model': insane_cpu, 'device': 'cpu'}
+    }
+    
+    return recommendations
+
+def print_system_summary(profile):
+    """Print a human-readable system summary"""
+    categories = categorize_system(profile)
+    
+    print(f"🖥️ System Profile:")
+    print(f"   VRAM: {profile['gpu']['total_mb']:,}MB total, {profile['available_vram_after_tts']:,}MB available after TTS ({categories['vram']} class)")
+    print(f"   RAM:  {profile['ram']['total_mb']:,}MB total, {profile['ram']['available_mb']:,}MB available ({categories['ram']} class)")
+    print(f"   CPU:  {profile['cpu_cores']} cores ({categories['cpu']} class)")
+    
+    if not profile['has_gpu']:
+        print(f"   ⚠️ No CUDA GPU detected - ASR will run on CPU only")
+
+if __name__ == "__main__":
+    # Test the detection
+    profile = get_system_profile()
+    print_system_summary(profile)
+    
+    recommendations = recommend_asr_models(profile)
+    print(f"\nASR Model Recommendations:")
+    for level, config in recommendations.items():
+        primary = config['primary']
+        fallback = config['fallback']
+        print(f"🟢 {level.upper()}: {primary['model']} ({primary['device']}) + {fallback['model']} (cpu fallback)")

modules/voice_detector.py

@@ -0,0 +1,240 @@
+"""
+Voice Detection Module
+Handles voice detection from multiple sources: JSON metadata, log files, filenames
+"""
+
+import re
+import json
+from pathlib import Path
+from config.config import AUDIOBOOK_ROOT
+from modules.file_manager import list_voice_samples
+
+
+def get_likely_voices_for_book(book_name, chunks_json_path=None):
+    """
+    Get the most likely voice candidates for a book using the 3 detection methods:
+    1. JSON metadata/comments (if available)
+    2. run.log file 
+    3. Generated audiobook filenames (may return multiple)
+    
+    Returns: list of (voice_name, voice_path, detection_method) tuples
+    """
+    print(f"🔍 Finding likely voices for book: {book_name}")
+    likely_voices = []
+    
+    # Method 1: Check JSON metadata and comments
+    if chunks_json_path:
+        voice_from_json = get_voice_from_json(chunks_json_path)
+        if voice_from_json:
+            voice_path = find_voice_file_by_name(voice_from_json)
+            if voice_path:
+                likely_voices.append((voice_from_json, voice_path, "json_metadata"))
+                print(f"✅ Voice found in JSON: {voice_from_json}")
+    
+    # Method 2: Check run.log file
+    voice_from_log = get_voice_from_log(book_name)
+    if voice_from_log:
+        voice_path = find_voice_file_by_name(voice_from_log)
+        if voice_path:
+            # Avoid duplicates
+            if not any(v[0] == voice_from_log for v in likely_voices):
+                likely_voices.append((voice_from_log, voice_path, "run_log"))
+                print(f"✅ Voice found in run.log: {voice_from_log}")
+    
+    # Method 3: Check generated filename patterns (may find multiple)
+    voices_from_files = get_voices_from_filenames(book_name)
+    for voice_name in voices_from_files:
+        voice_path = find_voice_file_by_name(voice_name)
+        if voice_path:
+            # Avoid duplicates
+            if not any(v[0] == voice_name for v in likely_voices):
+                likely_voices.append((voice_name, voice_path, "filename_pattern"))
+                print(f"✅ Voice found in filename: {voice_name}")
+    
+    if not likely_voices:
+        print(f"⚠️ No likely voices detected for {book_name}")
+    else:
+        print(f"📋 Found {len(likely_voices)} likely voice candidates")
+    
+    return likely_voices
+
+def detect_voice_for_book(book_name, chunks_json_path=None):
+    """
+    Detect the most likely voice for a book (returns first candidate)
+    For backwards compatibility with existing code
+    """
+    likely_voices = get_likely_voices_for_book(book_name, chunks_json_path)
+    if likely_voices:
+        return likely_voices[0]  # Return the first (most likely) candidate
+    return None, None, "not_found"
+
+
+def get_voice_from_json(json_path):
+    """Extract voice information from JSON metadata"""
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Check for voice metadata in JSON
+        if '"voice_used":' in content:
+            data = json.loads(content)
+            if isinstance(data, dict) and 'voice_used' in data:
+                return data['voice_used']
+            elif isinstance(data, list) and data and 'voice_used' in data[0]:
+                return data[0]['voice_used']
+        
+        # Check for voice as comment in JSON (fallback option)
+        voice_comment_match = re.search(r'//\s*voice:\s*([^\n]+)', content, re.IGNORECASE)
+        if voice_comment_match:
+            return voice_comment_match.group(1).strip()
+            
+    except Exception as e:
+        print(f"⚠️ Error reading JSON for voice info: {e}")
+    
+    return None
+
+
+def get_voice_from_log(book_name):
+    """Extract voice information from run.log file"""
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    log_file = audiobook_root / book_name / "run.log"
+    
+    if log_file.exists():
+        try:
+            with open(log_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith("Voice: ") or line.startswith("Voice used: "):
+                        voice_name = line.split(": ", 1)[1].strip()
+                        return voice_name
+        except Exception as e:
+            print(f"⚠️ Error reading run log: {e}")
+    
+    return None
+
+
+def get_voices_from_filenames(book_name):
+    """Extract voice names from existing audiobook filename patterns (may return multiple)"""
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    book_dir = audiobook_root / book_name
+    
+    if not book_dir.exists():
+        return []
+    
+    found_voices = []
+    
+    # Look for WAV files with voice pattern: BookName [VoiceName].wav
+    for wav_file in book_dir.glob("*.wav"):
+        match = re.search(r'\[([^\]]+)\]\.wav$', wav_file.name)
+        if match:
+            voice_name = match.group(1)
+            if voice_name not in found_voices:
+                found_voices.append(voice_name)
+    
+    # Look for M4B files with voice pattern: BookName[VoiceName].m4b  
+    for m4b_file in book_dir.glob("*.m4b"):
+        match = re.search(r'\[([^\]]+)\]\.m4b$', m4b_file.name)
+        if match:
+            voice_name = match.group(1)
+            if voice_name not in found_voices:
+                found_voices.append(voice_name)
+    
+    return found_voices
+
+def get_voice_from_filename(book_name):
+    """Extract voice name from existing audiobook filename patterns (backwards compatibility)"""
+    voices = get_voices_from_filenames(book_name)
+    return voices[0] if voices else None
+
+
+def find_voice_file_by_name(voice_name):
+    """Find voice file by name in Voice_Samples directory"""
+    voice_files = list_voice_samples()
+    
+    # Exact match first
+    for voice_file in voice_files:
+        if voice_file.stem == voice_name:
+            return voice_file
+    
+    # Partial match (case insensitive)
+    voice_name_lower = voice_name.lower()
+    for voice_file in voice_files:
+        if voice_name_lower in voice_file.stem.lower():
+            return voice_file
+    
+    return None
+
+
+
+
+def add_voice_to_json(json_path, voice_name, method="metadata"):
+    """
+    Add voice information to JSON file
+    
+    method options:
+    - "metadata": Add as top-level metadata
+    - "comment": Add as comment that doesn't affect parsing
+    """
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        if method == "metadata":
+            # Add voice as metadata to JSON structure
+            data = json.loads(content)
+            
+            if isinstance(data, list):
+                # For list format, add metadata as first element or update existing
+                if data and isinstance(data[0], dict) and not any(key.startswith('text') for key in data[0].keys()):
+                    # First element is already metadata
+                    data[0]['voice_used'] = voice_name
+                else:
+                    # Insert metadata as first element
+                    metadata = {"voice_used": voice_name, "_metadata": True}
+                    data.insert(0, metadata)
+            elif isinstance(data, dict):
+                # For dict format, add to top level
+                data['voice_used'] = voice_name
+            
+            # Save updated JSON
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+                
+        elif method == "comment":
+            # Add voice as comment at the top of file
+            voice_comment = f"// voice: {voice_name}\n"
+            
+            if not content.startswith("// voice:"):
+                content = voice_comment + content
+                with open(json_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+        
+        print(f"✅ Added voice '{voice_name}' to {json_path.name} using {method} method")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error adding voice to JSON: {e}")
+        return False
+
+
+def remove_voice_comment_from_json(json_path):
+    """Remove voice comment from JSON file for clean processing"""
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Remove voice comment lines
+        lines = content.split('\n')
+        filtered_lines = [line for line in lines if not line.strip().startswith('// voice:')]
+        
+        if len(filtered_lines) != len(lines):
+            # Comments were removed, save cleaned version
+            cleaned_content = '\n'.join(filtered_lines)
+            with open(json_path, 'w', encoding='utf-8') as f:
+                f.write(cleaned_content)
+            return True
+            
+    except Exception as e:
+        print(f"⚠️ Error cleaning JSON comments: {e}")
+    
+    return False

requirements.txt

@@ -0,0 +1,55 @@
+# ChatterboxTTS HuggingFace Spaces Requirements
+# Optimized for HF Spaces environment with flexible versions
+
+# Core ML and TTS - Essential (flexible versions for HF compatibility)
+torch>=2.0.0
+torchaudio>=2.0.0
+transformers>=4.20.0
+huggingface_hub>=0.15.0
+safetensors>=0.3.0
+
+# Audio processing - Required
+soundfile>=0.12.0
+librosa>=0.9.0
+pydub>=0.25.0
+audioread>=3.0.0
+
+# ASR System - Intelligent ASR with fallback
+openai-whisper>=20231117
+
+# System monitoring and resource detection
+psutil>=5.8.0
+pynvml>=11.0.0
+
+# Core scientific computing (flexible for HF environment)
+numpy>=1.21.0
+scipy>=1.7.0
+
+# Text processing
+regex>=2023.0.0
+vaderSentiment>=3.3.0
+
+# Web interface - Gradio (let HF manage version)
+gradio>=4.0.0
+
+# Progress and logging
+tqdm>=4.60.0
+
+# File handling
+pathlib2>=2.3.0
+
+# Configuration and utilities
+python-dotenv>=1.0.0
+
+# Optional utilities
+requests>=2.25.0
+packaging>=21.0
+
+# Core ChatterboxTTS model dependencies
+resemble-perth>=1.0.1
+omegaconf>=2.3.0
+einops>=0.6.0
+diffusers>=0.21.0
+tokenizers>=0.13.0
+conformer>=0.3.0
+s3tokenizer==0.2.0

tools/combine_only.py

@@ -0,0 +1,396 @@
+"""
+Combine Only Tool
+Standalone tool for combining existing audio chunks into final audiobook
+"""
+
+import re
+import time
+import logging
+from datetime import timedelta
+from pathlib import Path
+
+from config.config import *
+from modules.file_manager import (
+    get_audio_files_in_directory, combine_audio_chunks,
+    convert_to_m4b, add_metadata_to_m4b, find_book_files
+)
+from modules.audio_processor import get_wav_duration
+from modules.progress_tracker import log_console, log_run
+import subprocess
+import shutil
+
+def combine_audio_for_book(book_path_str, voice_name=None):
+    """Combine audio chunks for a specific book (GUI-friendly version)"""
+    from pathlib import Path
+    book_path = Path(book_path_str)
+    
+    print(f"\n{CYAN}🔗 Combining Audio Chunks for: {book_path.name}{RESET}")
+    print("=" * 60)
+    
+    # Setup paths
+    tts_dir = book_path / "TTS"
+    audio_chunks_dir = tts_dir / "audio_chunks"
+
+    if not audio_chunks_dir.exists():
+        print(f"{RED}❌ No audio_chunks folder found in {book_path}{RESET}")
+        print(f"💡 Make sure this book has been processed with TTS generation first.")
+        return False
+
+    # Find audio chunks
+    chunk_paths = get_audio_files_in_directory(audio_chunks_dir)
+
+    if not chunk_paths:
+        print(f"{RED}❌ No chunk_*.wav files found in {audio_chunks_dir}{RESET}")
+        print(f"💡 Expected files like: chunk_00001.wav, chunk_00002.wav, etc.")
+        return False
+
+    print(f"\n📦 Found {GREEN}{len(chunk_paths)}{RESET} audio chunks")
+
+    # Verify chunk sequence
+    missing_chunks = verify_chunk_sequence(chunk_paths)
+    if missing_chunks:
+        print(f"\n⚠️ {YELLOW}Warning: Missing chunks detected:{RESET}")
+        for chunk_num in missing_chunks[:10]:  # Show first 10 missing
+            print(f"   Missing: chunk_{chunk_num:05}.wav")
+        if len(missing_chunks) > 10:
+            print(f"   ... and {len(missing_chunks) - 10} more")
+        print(f"{YELLOW}🔄 Continuing with available chunks for GUI operation...{RESET}")
+
+    # Display chunk info
+    total_duration = sum(get_wav_duration(chunk_path) for chunk_path in chunk_paths)
+    duration_str = str(timedelta(seconds=int(total_duration)))
+
+    print(f"\n📊 Chunk Analysis:")
+    print(f"   Total Chunks: {GREEN}{len(chunk_paths)}{RESET}")
+    print(f"   Total Duration: {GREEN}{duration_str}{RESET}")
+    print(f"   Average Chunk: {GREEN}{total_duration/len(chunk_paths):.1f}s{RESET}")
+
+    # Perform the actual combine operation
+    return _perform_combine_operation(book_path, chunk_paths, total_duration, voice_name)
+
+def _perform_combine_operation(book_path, chunk_paths, total_duration, voice_name=None):
+    """Perform the actual audio combining operation"""
+    import time
+    from datetime import timedelta
+    
+    basename = book_path.name
+    
+    # Determine file naming based on voice
+    if voice_name:
+        file_suffix = f" [{voice_name}]"
+    else:
+        file_suffix = "_combined"
+    
+    # Start timing
+    start_time = time.time()
+
+    # Create concat file and combine
+    print(f"\n🔗 Combining audio chunks...")
+    combined_wav_path = book_path / f"{basename}{file_suffix}.wav"
+
+    try:
+        combine_audio_chunks(chunk_paths, combined_wav_path)
+        print(f"✅ Combined WAV created: {combined_wav_path.name}")
+    except Exception as e:
+        print(f"{RED}❌ Failed to combine chunks: {e}{RESET}")
+        return False
+
+    # Find metadata files
+    text_book_dir = TEXT_INPUT_ROOT / basename
+    book_files = find_book_files(text_book_dir)
+    text_files, cover_file, nfo_file = book_files['text'], book_files['cover'], book_files['nfo']
+
+    if not cover_file:
+        print(f"⚠️ {YELLOW}No cover image found in {text_book_dir}{RESET}")
+    else:
+        print(f"📸 Using cover: {cover_file.name}")
+
+    if not nfo_file:
+        print(f"⚠️ {YELLOW}No book.nfo metadata found in {text_book_dir}{RESET}")
+    else:
+        print(f"📝 Using metadata: {nfo_file.name}")
+
+    # M4B conversion
+    print(f"\n📱 Converting to M4B audiobook...")
+    temp_m4b_path = book_path / "temp_output.m4b"
+    final_m4b_path = book_path / f"{basename}{file_suffix}.m4b"
+
+    try:
+        convert_to_m4b(combined_wav_path, temp_m4b_path)
+        add_metadata_to_m4b(temp_m4b_path, final_m4b_path, cover_file, nfo_file)
+        print(f"✅ M4B audiobook created: {final_m4b_path.name}")
+    except Exception as e:
+        print(f"{RED}❌ Failed to create M4B: {e}{RESET}")
+        return False
+
+    # Calculate final timing
+    elapsed_total = time.time() - start_time
+    elapsed_td = timedelta(seconds=int(elapsed_total))
+
+    # Verify final file
+    if final_m4b_path.exists():
+        final_size = final_m4b_path.stat().st_size / (1024 * 1024)  # MB
+        print(f"📦 Final file size: {GREEN}{final_size:.1f} MB{RESET}")
+        
+        # Calculate efficiency
+        realtime_factor = total_duration / elapsed_total if elapsed_total > 0 else 0
+        duration_str = str(timedelta(seconds=int(total_duration)))
+        
+        print(f"\n🎉 {GREEN}Combine completed successfully!{RESET}")
+        print(f"📊 Final Statistics:")
+        print(f"   Audio Duration: {GREEN}{duration_str}{RESET}")
+        print(f"   Processing Time: {GREEN}{elapsed_td}{RESET}")
+        print(f"   Realtime Factor: {GREEN}{realtime_factor:.2f}x{RESET}")
+        print(f"   Output Location: {GREEN}{final_m4b_path}{RESET}")
+        
+        # Clean up temp files
+        try:
+            if temp_m4b_path.exists():
+                temp_m4b_path.unlink()
+                print(f"🧹 Cleaned up temporary file: {temp_m4b_path.name}")
+        except Exception as e:
+            print(f"⚠️ Could not clean up temp file: {e}")
+            
+        return True
+    else:
+        print(f"{RED}❌ Final M4B file was not created successfully{RESET}")
+        return False
+
+def run_combine_only_mode():
+    """Combine existing chunks into audiobook (CLI version)"""
+    print(f"\n{CYAN}🔗 Combine-Only Mode: Assembling Existing Audio Chunks{RESET}")
+    print("=" * 60)
+
+    # Show available audiobooks
+    books = sorted([d for d in AUDIOBOOK_ROOT.iterdir() if d.is_dir()])
+    if not books:
+        print(f"{RED}❌ No folders found in Audiobook/ directory.{RESET}")
+        print(f"💡 Make sure you have processed books with audio chunks to combine.")
+        return None
+
+    print(f"{CYAN}Available audiobooks to combine:{RESET}")
+    for i, book in enumerate(books):
+        # Check if it has audio chunks
+        audio_chunks_dir = book / "TTS" / "audio_chunks"
+        if audio_chunks_dir.exists():
+            chunk_count = len(list(audio_chunks_dir.glob('chunk_*.wav')))
+            status = f"({chunk_count} chunks)" if chunk_count > 0 else "(no chunks)"
+            print(f"  [{i}] {book.name} {status}")
+        else:
+            print(f"  [{i}] {book.name} (no TTS folder)")
+
+    # Book selection
+    while True:
+        try:
+            idx = int(input(f"\n{YELLOW}Select audiobook index: {RESET}"))
+            if 0 <= idx < len(books):
+                break
+            else:
+                print(f"{RED}Invalid selection. Please enter a number between 0 and {len(books)-1}.{RESET}")
+        except (ValueError, KeyboardInterrupt):
+            print(f"{RED}Invalid selection. Please try again.{RESET}")
+        except EOFError:
+            print(f"\n{RED}❌ Input error - unable to read selection.{RESET}")
+            return None
+        except Exception as e:
+            print(f"{RED}❌ Unexpected error: {e}{RESET}")
+            return None
+
+    selected_book = books[idx]
+    basename = selected_book.name
+
+    print(f"\n🎯 Selected: {BOLD}{basename}{RESET}")
+
+    # Setup paths
+    tts_dir = selected_book / "TTS"
+    audio_chunks_dir = tts_dir / "audio_chunks"
+
+    if not audio_chunks_dir.exists():
+        print(f"{RED}❌ No audio_chunks folder found in {selected_book}{RESET}")
+        print(f"💡 Make sure this book has been processed with TTS generation first.")
+        return None
+
+    # Find audio chunks
+    chunk_paths = get_audio_files_in_directory(audio_chunks_dir)
+
+    if not chunk_paths:
+        print(f"{RED}❌ No chunk_*.wav files found in {audio_chunks_dir}{RESET}")
+        print(f"💡 Expected files like: chunk_00001.wav, chunk_00002.wav, etc.")
+        return None
+
+    print(f"\n📦 Found {GREEN}{len(chunk_paths)}{RESET} audio chunks")
+
+    # Verify chunk sequence
+    missing_chunks = verify_chunk_sequence(chunk_paths)
+    if missing_chunks:
+        print(f"\n⚠️ {YELLOW}Warning: Missing chunks detected:{RESET}")
+        for chunk_num in missing_chunks[:10]:  # Show first 10 missing
+            print(f"   Missing: chunk_{chunk_num:05}.wav")
+        if len(missing_chunks) > 10:
+            print(f"   ... and {len(missing_chunks) - 10} more")
+
+        try:
+            continue_anyway = input(f"\n{YELLOW}Continue with incomplete chunks? [y/N]: {RESET}").strip().lower()
+            if continue_anyway != 'y':
+                print("🛑 Combine operation cancelled.")
+                return None
+        except (EOFError, KeyboardInterrupt):
+            print(f"\n{RED}🛑 Combine operation cancelled.{RESET}")
+            return None
+
+    # Display chunk info
+    total_duration = sum(get_wav_duration(chunk_path) for chunk_path in chunk_paths)
+    duration_str = str(timedelta(seconds=int(total_duration)))
+
+    print(f"\n📊 Chunk Analysis:")
+    print(f"   Total Chunks: {GREEN}{len(chunk_paths)}{RESET}")
+    print(f"   Total Duration: {GREEN}{duration_str}{RESET}")
+    print(f"   Average Chunk: {GREEN}{total_duration/len(chunk_paths):.1f}s{RESET}")
+
+    # Use the shared combine operation (CLI doesn't pass voice name)
+    success = _perform_combine_operation(selected_book, chunk_paths, total_duration)
+    
+    if success:
+        return selected_book / f"{basename}_combined.m4b"
+    else:
+        return None
+
+def verify_chunk_sequence(chunk_paths):
+    """Verify chunk sequence and return missing chunk numbers"""
+    chunk_numbers = []
+
+    for chunk_path in chunk_paths:
+        match = re.match(r"chunk_(\d+)\.wav", chunk_path.name)
+        if match:
+            chunk_numbers.append(int(match.group(1)))
+
+    if not chunk_numbers:
+        return []
+
+    chunk_numbers.sort()
+    expected_range = range(1, max(chunk_numbers) + 1)
+    missing = [num for num in expected_range if num not in chunk_numbers]
+
+    return missing
+
+def list_available_books_for_combine():
+    """List books available for combine operation"""
+    books_info = []
+
+    if not AUDIOBOOK_ROOT.exists():
+        return books_info
+
+    for book_dir in AUDIOBOOK_ROOT.iterdir():
+        if not book_dir.is_dir():
+            continue
+
+        audio_chunks_dir = book_dir / "TTS" / "audio_chunks"
+        if not audio_chunks_dir.exists():
+            continue
+
+        chunk_paths = get_audio_files_in_directory(audio_chunks_dir)
+        if not chunk_paths:
+            continue
+
+        # Calculate total duration
+        try:
+            total_duration = sum(get_wav_duration(chunk_path) for chunk_path in chunk_paths)
+            duration_str = str(timedelta(seconds=int(total_duration)))
+        except:
+            duration_str = "Unknown"
+
+        books_info.append({
+            "name": book_dir.name,
+            "path": book_dir,
+            "chunk_count": len(chunk_paths),
+            "duration": duration_str
+        })
+
+    return books_info
+
+def quick_combine(book_name):
+    """Quick combine operation for specific book (CLI usage)"""
+    book_path = AUDIOBOOK_ROOT / book_name
+
+    if not book_path.exists():
+        print(f"{RED}❌ Book '{book_name}' not found in Audiobook directory{RESET}")
+        return None
+
+    audio_chunks_dir = book_path / "TTS" / "audio_chunks"
+    chunk_paths = get_audio_files_in_directory(audio_chunks_dir)
+
+    if not chunk_paths:
+        print(f"{RED}❌ No audio chunks found for '{book_name}'{RESET}")
+        return None
+
+    print(f"🔗 Quick combining {len(chunk_paths)} chunks for '{book_name}'...")
+
+    # Use same logic as main function but without interactive prompts
+    combined_wav_path = book_path / f"{book_name}_quick_combined.wav"
+    final_m4b_path = book_path / f"{book_name}_quick_combined.m4b"
+
+    combine_audio_chunks(chunk_paths, combined_wav_path)
+
+    temp_m4b_path = book_path / "temp_quick.m4b"
+    convert_to_m4b(combined_wav_path, temp_m4b_path)
+
+    # Simple M4B without metadata for quick operation
+    temp_m4b_path.rename(final_m4b_path)
+
+    print(f"✅ Quick combine complete: {final_m4b_path}")
+    return final_m4b_path
+
+def apply_playback_speed_to_m4b(input_m4b_path, output_m4b_path, speed_factor):
+    """Apply playback speed adjustment to M4B file using ffmpeg"""
+    try:
+        print(f"🔄 Applying {speed_factor}x speed to {Path(input_m4b_path).name}")
+        
+        # Check if ffmpeg is available
+        if not shutil.which('ffmpeg'):
+            print("❌ ffmpeg not found - required for M4B speed adjustment")
+            return False
+        
+        # Build ffmpeg command for speed adjustment
+        cmd = [
+            'ffmpeg', '-y',  # -y to overwrite output file
+            '-i', str(input_m4b_path),
+            '-filter:a', f'atempo={speed_factor}',  # Audio speed adjustment
+            '-c:a', 'aac',  # Re-encode to AAC for M4B compatibility
+            '-b:a', '64k',  # Audio bitrate
+            str(output_m4b_path)
+        ]
+        
+        print(f"Running: {' '.join(cmd)}")
+        
+        # Execute ffmpeg command
+        result = subprocess.run(
+            cmd, 
+            capture_output=True, 
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        if result.returncode == 0:
+            print(f"✅ Successfully created speed-adjusted M4B: {Path(output_m4b_path).name}")
+            return True
+        else:
+            print(f"❌ ffmpeg failed: {result.stderr}")
+            return False
+            
+    except subprocess.TimeoutExpired:
+        print("❌ M4B speed adjustment timed out")
+        return False
+    except Exception as e:
+        print(f"❌ Error adjusting M4B speed: {e}")
+        return False
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        # CLI usage: python combine_only.py "Book Name"
+        book_name = sys.argv[1]
+        quick_combine(book_name)
+    else:
+        # Interactive mode
+        run_combine_only_mode()

utils/abbreviations.txt

@@ -0,0 +1,11 @@
+Dr. -> Doctor
+Mr. -> Mister
+Mrs. -> Missus
+Ms. -> Miss
+U.S. -> US
+U.K. -> UK
+etc. -> et cetera
+vs. -> versus
+1st -> first
+2nd -> second
+3rd -> third

utils/chunk_manager.TXT

@@ -0,0 +1,153 @@
+# chunk_manager.py
+
+import re
+from pathlib import Path
+from text_cleaner import smart_punctuate  # Assuming you've extracted this already
+
+import json
+
+def save_chunks_to_json(chunks, output_path):
+    """Save enriched chunk list to a JSON file"""
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(chunks, f, indent=2, ensure_ascii=False)
+    print(f"✅ Saved {len(chunks)} chunks to: {output_path}")
+
+
+def break_long_sentence(sentence, max_words):
+    break_patterns = [
+        r'(,\s+and\s+)', r'(,\s+but\s+)', r'(,\s+)', r'(;\s*)', r'—', r'(\.\s*")',
+    ]
+    chunks = []
+    remaining_text = sentence.strip()
+
+    while remaining_text:
+        words = remaining_text.split()
+        if len(words) <= max_words:
+            chunks.append(remaining_text.strip())
+            break
+
+        for pattern in break_patterns:
+            for match in re.finditer(pattern, remaining_text):
+                break_pos = match.end()
+                candidate = remaining_text[:break_pos].strip()
+                if len(candidate.split()) <= max_words:
+                    chunks.append(candidate)
+                    remaining_text = remaining_text[break_pos:].strip()
+                    break
+            else:
+                continue
+            break
+        else:
+            forced = " ".join(words[:max_words]) + ","
+            chunks.append(forced)
+            remaining_text = " ".join(words[max_words:]).strip()
+
+    return chunks
+
+def fix_short_sentences(chunk_text):
+    short = re.findall(r'\b[A-Z][a-z]{1,3}\.\s+', chunk_text)
+    if len(short) >= 2:
+        merged = chunk_text.replace(". ", ", ")
+        if not merged.endswith("."):
+            merged += "."
+        return merged
+    return chunk_text
+
+def detect_content_boundary(chunk_text):
+    if re.match(r'^\s*(Chapter \d+|CHAPTER \d+)', chunk_text, re.IGNORECASE):
+        return "chapter_start"
+    if re.search(r'\*\*\*|---|###', chunk_text):
+        return "section_break"
+    if chunk_text.endswith('\n\n') or chunk_text.endswith('\n'):
+        return "paragraph_end"
+    return None
+
+def sentence_chunk_text(text, max_words=30, min_words=4):
+    sentence_end_re = re.compile(r'([.!?][\"\')]*\s+)')
+    lines = text.splitlines()
+    paragraph_buffer = []
+    final_chunks = []
+
+    def flush_paragraph(lines_in_para):
+        raw_sentences = []
+
+        for line in lines_in_para:
+            start = 0
+            for match in sentence_end_re.finditer(line):
+                end = match.end()
+                sentence = line[start:end].strip()
+                if sentence:
+                    raw_sentences.append(sentence)
+                start = end
+            if start < len(line):
+                sentence = line[start:].strip()
+                if sentence:
+                    raw_sentences.append(sentence)
+
+        # Now group into chunks
+        temp_chunks = []
+        short_group = []
+
+        for sentence in raw_sentences:
+            wc = len(sentence.split())
+
+            if wc > max_words:
+                split_chunks = break_long_sentence(sentence, max_words)
+                for chunk in split_chunks:
+                    temp_chunks.append(chunk.strip())
+            elif wc < min_words:
+                short_group.append(sentence)
+            else:
+                if short_group:
+                    merged_text = ", ".join(short_group + [sentence])
+                    temp_chunks.append(merged_text.strip())
+                    short_group = []
+                else:
+                    temp_chunks.append(sentence.strip())
+
+        if short_group:
+            merged_text = ", ".join(short_group)
+            temp_chunks.append(merged_text.strip())
+
+        # Apply proper paragraph end tagging
+        for i, chunk in enumerate(temp_chunks):
+            final_chunks.append((
+                fix_short_sentences(chunk),
+                True if i == len(temp_chunks) - 1 else False
+            ))
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            flush_paragraph(paragraph_buffer)
+            paragraph_buffer = []
+        else:
+            paragraph_buffer.append(stripped)
+
+    # Flush any remaining paragraph
+    if paragraph_buffer:
+        flush_paragraph(paragraph_buffer)
+
+    return final_chunks
+
+
+
+def prechunk_text_file(path, max_words=30, min_words=4):
+    raw = Path(path).read_text(encoding='utf-8')
+    text = smart_punctuate(raw)
+    chunks = sentence_chunk_text(text, max_words=max_words, min_words=min_words)
+
+    enriched_chunks = []
+    for i, (chunk_text, is_para_end) in enumerate(chunks):
+        boundary = detect_content_boundary(chunk_text)
+
+        enriched_chunks.append({
+            "index": i,
+            "text": chunk_text.strip(),
+            "word_count": len(chunk_text.strip().split()),
+            "boundary_type": boundary or "none",
+            "is_paragraph_end": is_para_end
+        })
+
+
+    return enriched_chunks

utils/dirlist.TXT

@@ -0,0 +1,49 @@
+import os
+
+def list_directory_recursively(start_path):
+    """
+    Lists all folders and their files recursively starting from the given path.
+
+    Args:
+        start_path (str): The path to the directory to start listing from.
+    """
+    if not os.path.isdir(start_path):
+        print(f"Error: '{start_path}' is not a valid directory.")
+        return
+
+    print(f"Listing contents of: {start_path}\n")
+
+    # os.walk yields a 3-tuple: (dirpath, dirnames, filenames)
+    # dirpath: The path of the current directory.
+    # dirnames: A list of the names of the subdirectories in dirpath (not full paths).
+    # filenames: A list of the names of the non-directory files in dirpath (not full paths).
+    for root, dirs, files in os.walk(start_path):
+        # Print the current directory path
+        # Use os.path.relpath to show path relative to start_path, or keep root for full path
+        relative_root = os.path.relpath(root, start_path)
+        if relative_root == '.':
+            # This is the starting directory itself
+            print(f"Folder: {os.path.basename(root)}/")
+        else:
+            print(f"Folder: {relative_root}/")
+
+        # Print files in the current directory
+        if files:
+            for file in sorted(files): # Sort files for consistent output
+                print(f"  File: {file}")
+
+        # You can also print subdirectories found at this level if you wish
+        # for dir_name in sorted(dirs):
+        #     print(f"  Subfolder: {dir_name}/")
+
+        print() # Add an empty line for readability between folders
+
+if __name__ == "__main__":
+    # Example usage:
+    # Get directory path from user
+    directory_to_list = input("Enter the path to the Linux directory you want to list (e.g., /home/user/documents): ")
+
+    list_directory_recursively(directory_to_list)
+
+    # You can also hardcode a path for testing:
+    # list_directory_recursively("/path/to/your/test_directory")

utils/generate_from_json (copy).py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Direct Audio Generation from JSON Tool
+
+This script allows for generating audiobook chunks directly from a pre-existing
+`chunks_info.json` file. It is intended for debugging and testing purposes,
+allowing a user to manually edit the TTS parameters in the JSON file and
+hear the results without the VADER analysis step.
+"""
+
+import torch
+from pathlib import Path
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+from datetime import timedelta
+
+# Add project root to path to allow module imports
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from config.config import *
+from modules.tts_engine import load_optimized_model, process_one_chunk
+from modules.file_manager import setup_book_directories, list_voice_samples, ensure_voice_sample_compatibility
+from wrapper.chunk_loader import load_chunks
+from chatterbox.tts import punc_norm
+from modules.progress_tracker import log_chunk_progress, log_run
+
+def main():
+    """Main function to drive the generation process."""
+    print(f"{BOLD}{CYAN}--- Direct Audio Generation from JSON Tool ---\{RESET}")
+    
+    # 1. Get Book Name
+    book_name = input("Enter the book name (e.g., 'london'): ").strip()
+    if not book_name:
+        print("❌ Book name cannot be empty.")
+        return
+
+    # 2. Locate and Load JSON
+    book_audio_dir = AUDIOBOOK_ROOT / book_name
+    json_path = book_audio_dir / "TTS" / "text_chunks" / "chunks_info.json"
+
+    if not json_path.exists():
+        print(f"❌ Error: JSON file not found at {json_path}")
+        print("Please ensure you have run the 'Prepare text file' option for this book first.")
+        return
+
+    print(f"📖 Loading chunks from: {json_path}")
+    all_chunks = load_chunks(str(json_path))
+    print(f"✅ Found {len(all_chunks)} chunks.")
+
+    # 3. Select Voice
+    voice_files = list_voice_samples()
+    if not voice_files:
+        print(f"❌ No voice samples found in {VOICE_SAMPLES_DIR}")
+        return
+
+    print("\nAvailable voices:")
+    for i, voice_file in enumerate(voice_files, 1):
+        print(f" [{i}] {voice_file.stem}")
+    
+    while True:
+        try:
+            choice = input("Select voice number: ").strip()
+            idx = int(choice) - 1
+            if 0 <= idx < len(voice_files):
+                voice_path = voice_files[idx]
+                break
+            print("Invalid selection.")
+        except (ValueError, IndexError):
+            print("Invalid selection.")
+    
+    # Ensure voice compatibility
+    voice_path = ensure_voice_sample_compatibility(voice_path)
+
+    # 4. Setup Environment
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available():
+        device = "mps"
+    else:
+        device = "cpu"
+    
+    print(f"\n🚀 Using device: {device}")
+    print(f"🎤 Using voice: {Path(voice_path).name}")
+
+    # 5. Load Model
+    model = load_optimized_model(device)
+    
+    # 6. Prepare voice conditionals (THIS WAS MISSING!)
+    print(f"🎤 Preparing voice conditionals with: {Path(voice_path).name}")
+    model.prepare_conditionals(voice_path)
+
+    # 7. Process Chunks
+    output_root, tts_dir, text_chunks_dir, audio_chunks_dir = setup_book_directories(Path(TEXT_INPUT_ROOT) / book_name)
+    
+    # Clean existing audio chunks
+    print("🧹 Clearing old audio chunks...")
+    for wav_file in audio_chunks_dir.glob("*.wav"):
+        wav_file.unlink()
+
+    start_time = time.time()
+    total_chunks = len(all_chunks)
+    log_path = output_root / "debug_generation.log"
+    
+    print(f"\n🔄 Generating {total_chunks} chunks...")
+
+    with ThreadPoolExecutor(max_workers=1) as executor: # Force sequential processing
+        futures = []
+        for i, chunk_data in enumerate(all_chunks):
+            # Extract exaggeration from JSON, force others to default
+            chunk_tts_params = {
+                "exaggeration": chunk_data.get("tts_params", {}).get("exaggeration", DEFAULT_EXAGGERATION),
+                "cfg_weight": DEFAULT_CFG_WEIGHT,
+                "temperature": DEFAULT_TEMPERATURE
+            }
+
+            future = executor.submit(
+                process_one_chunk,
+                i, chunk_data['text'], text_chunks_dir, audio_chunks_dir,
+                voice_path, chunk_tts_params, start_time, total_chunks,
+                punc_norm, book_name, log_run, log_path, device,
+                model, None, chunk_data['is_paragraph_end'], all_chunks, chunk_data['boundary_type']
+            )
+            futures.append(future)
+
+        for future in as_completed(futures):
+            try:
+                result = future.result()
+                if result:
+                    idx, _ = result
+                    log_chunk_progress(idx, total_chunks, start_time, 0)
+            except Exception as e:
+                print(f"\n❌ An error occurred while processing a chunk: {e}")
+
+    elapsed_time = time.time() - start_time
+    print(f"\n{GREEN}✅ Generation Complete!{RESET}")
+    print(f"⏱️ Total time: {timedelta(seconds=int(elapsed_time))}")
+    print(f"🔊 Audio chunks are in: {audio_chunks_dir}")
+    print("You can now use Option 3 from the main menu to combine them.")
+
+if __name__ == "__main__":
+    main()

utils/generate_from_json.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Direct Audio Generation from JSON Tool
+
+This script allows for generating audiobook chunks directly from a pre-existing
+`chunks_info.json` file. It is intended for debugging and testing purposes,
+allowing a user to manually edit the TTS parameters in the JSON file and
+hear the results without the VADER analysis step.
+"""
+
+import torch
+from pathlib import Path
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+from datetime import timedelta
+
+# Add project root to path to allow module imports
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from config.config import *
+from modules.tts_engine import load_optimized_model, process_one_chunk
+from modules.file_manager import setup_book_directories, list_voice_samples, ensure_voice_sample_compatibility
+from wrapper.chunk_loader import load_chunks
+from chatterbox.tts import punc_norm
+from modules.progress_tracker import log_chunk_progress, log_run
+
+def main():
+    """Main function to drive the generation process."""
+    print(f"{BOLD}{CYAN}--- Direct Audio Generation from JSON Tool ---\{RESET}")
+    
+    # 1. Get Book Name
+    book_name = input("Enter the book name (e.g., 'london'): ").strip()
+    if not book_name:
+        print("❌ Book name cannot be empty.")
+        return
+
+    # 2. Locate and Load JSON
+    book_audio_dir = AUDIOBOOK_ROOT / book_name
+    json_path = book_audio_dir / "TTS" / "text_chunks" / "chunks_info.json"
+
+    if not json_path.exists():
+        print(f"❌ Error: JSON file not found at {json_path}")
+        print("Please ensure you have run the 'Prepare text file' option for this book first.")
+        return
+
+    print(f"📖 Loading chunks from: {json_path}")
+    all_chunks = load_chunks(str(json_path))
+    print(f"✅ Found {len(all_chunks)} chunks.")
+
+    # 3. Select Voice
+    voice_files = list_voice_samples()
+    if not voice_files:
+        print(f"❌ No voice samples found in {VOICE_SAMPLES_DIR}")
+        return
+
+    print("\nAvailable voices:")
+    for i, voice_file in enumerate(voice_files, 1):
+        print(f" [{i}] {voice_file.stem}")
+    
+    while True:
+        try:
+            choice = input("Select voice number: ").strip()
+            idx = int(choice) - 1
+            if 0 <= idx < len(voice_files):
+                voice_path = voice_files[idx]
+                break
+            print("Invalid selection.")
+        except (ValueError, IndexError):
+            print("Invalid selection.")
+    
+    # Ensure voice compatibility
+    voice_path = ensure_voice_sample_compatibility(voice_path)
+
+    # 4. Setup Environment
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available():
+        device = "mps"
+    else:
+        device = "cpu"
+    
+    print(f"\n🚀 Using device: {device}")
+    print(f"🎤 Using voice: {Path(voice_path).name}")
+
+    # 5. Load Model
+    model = load_optimized_model(device)
+    
+    # 6. Prepare voice conditionals (THIS WAS MISSING!)
+    print(f"🎤 Preparing voice conditionals with: {Path(voice_path).name}")
+    model.prepare_conditionals(voice_path)
+
+    # 7. Process Chunks
+    output_root, tts_dir, text_chunks_dir, audio_chunks_dir = setup_book_directories(Path(TEXT_INPUT_ROOT) / book_name)
+    
+    # Clean existing audio chunks
+    print("🧹 Clearing old audio chunks...")
+    for wav_file in audio_chunks_dir.glob("*.wav"):
+        wav_file.unlink()
+
+    start_time = time.time()
+    total_chunks = len(all_chunks)
+    log_path = output_root / "debug_generation.log"
+    
+    print(f"\n🔄 Generating {total_chunks} chunks...")
+
+    with ThreadPoolExecutor(max_workers=2) as executor: # Test parallel processing
+        futures = []
+        for i, chunk_data in enumerate(all_chunks):
+            # Extract exaggeration from JSON, force others to default
+            chunk_tts_params = {
+                "exaggeration": chunk_data.get("tts_params", {}).get("exaggeration", DEFAULT_EXAGGERATION),
+                "cfg_weight": DEFAULT_CFG_WEIGHT,
+                "temperature": DEFAULT_TEMPERATURE
+            }
+
+            future = executor.submit(
+                process_one_chunk,
+                i, chunk_data['text'], text_chunks_dir, audio_chunks_dir,
+                voice_path, chunk_tts_params, start_time, total_chunks,
+                punc_norm, book_name, log_run, log_path, device,
+                model, None, all_chunks, chunk_data['boundary_type']
+            )
+            futures.append(future)
+
+        for future in as_completed(futures):
+            try:
+                result = future.result()
+                if result:
+                    idx, _ = result
+                    log_chunk_progress(idx, total_chunks, start_time, 0)
+            except Exception as e:
+                print(f"\n❌ An error occurred while processing a chunk: {e}")
+
+    elapsed_time = time.time() - start_time
+    print(f"\n{GREEN}✅ Generation Complete!{RESET}")
+    print(f"⏱️ Total time: {timedelta(seconds=int(elapsed_time))}")
+    print(f"🔊 Audio chunks are in: {audio_chunks_dir}")
+    print("You can now use Option 3 from the main menu to combine them.")
+
+if __name__ == "__main__":
+    main()

utils/generate_from_json.py.bak

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Direct Audio Generation from JSON Tool
+
+This script allows for generating audiobook chunks directly from a pre-existing
+`chunks_info.json` file. It is intended for debugging and testing purposes,
+allowing a user to manually edit the TTS parameters in the JSON file and
+hear the results without the VADER analysis step.
+"""
+
+import torch
+from pathlib import Path
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+from datetime import timedelta
+
+# Add project root to path to allow module imports
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from config.config import *
+from modules.tts_engine import load_optimized_model, process_one_chunk
+from modules.file_manager import setup_book_directories, list_voice_samples, ensure_voice_sample_compatibility
+from wrapper.chunk_loader import load_chunks
+from chatterbox.tts import punc_norm
+from modules.progress_tracker import log_chunk_progress, log_run
+
+def main():
+    """Main function to drive the generation process."""
+    print(f"{BOLD}{CYAN}--- Direct Audio Generation from JSON Tool ---\{RESET}")
+    
+    # 1. Get Book Name
+    book_name = input("Enter the book name (e.g., 'london'): ").strip()
+    if not book_name:
+        print("❌ Book name cannot be empty.")
+        return
+
+    # 2. Locate and Load JSON
+    book_audio_dir = AUDIOBOOK_ROOT / book_name
+    json_path = book_audio_dir / "TTS" / "text_chunks" / "chunks_info.json"
+
+    if not json_path.exists():
+        print(f"❌ Error: JSON file not found at {json_path}")
+        print("Please ensure you have run the 'Prepare text file' option for this book first.")
+        return
+
+    print(f"📖 Loading chunks from: {json_path}")
+    all_chunks = load_chunks(str(json_path))
+    print(f"✅ Found {len(all_chunks)} chunks.")
+
+    # 3. Select Voice
+    voice_files = list_voice_samples()
+    if not voice_files:
+        print(f"❌ No voice samples found in {VOICE_SAMPLES_DIR}")
+        return
+
+    print("\nAvailable voices:")
+    for i, voice_file in enumerate(voice_files, 1):
+        print(f" [{i}] {voice_file.stem}")
+    
+    while True:
+        try:
+            choice = input("Select voice number: ").strip()
+            idx = int(choice) - 1
+            if 0 <= idx < len(voice_files):
+                voice_path = voice_files[idx]
+                break
+            print("Invalid selection.")
+        except (ValueError, IndexError):
+            print("Invalid selection.")
+    
+    # Ensure voice compatibility
+    voice_path = ensure_voice_sample_compatibility(voice_path)
+
+    # 4. Setup Environment
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available():
+        device = "mps"
+    else:
+        device = "cpu"
+    
+    print(f"\n🚀 Using device: {device}")
+    print(f"🎤 Using voice: {Path(voice_path).name}")
+
+    # 5. Load Model
+    model = load_optimized_model(device)
+    
+    # 6. Prepare voice conditionals (THIS WAS MISSING!)
+    print(f"🎤 Preparing voice conditionals with: {Path(voice_path).name}")
+    model.prepare_conditionals(voice_path)
+
+    # 7. Process Chunks
+    output_root, tts_dir, text_chunks_dir, audio_chunks_dir = setup_book_directories(Path(TEXT_INPUT_ROOT) / book_name)
+    
+    # Clean existing audio chunks
+    print("🧹 Clearing old audio chunks...")
+    for wav_file in audio_chunks_dir.glob("*.wav"):
+        wav_file.unlink()
+
+    start_time = time.time()
+    total_chunks = len(all_chunks)
+    log_path = output_root / "debug_generation.log"
+    
+    print(f"\n🔄 Generating {total_chunks} chunks...")
+
+    with ThreadPoolExecutor(max_workers=2) as executor: # Test parallel processing
+        futures = []
+        for i, chunk_data in enumerate(all_chunks):
+            # Extract exaggeration from JSON, force others to default
+            chunk_tts_params = {
+                "exaggeration": chunk_data.get("tts_params", {}).get("exaggeration", DEFAULT_EXAGGERATION),
+                "cfg_weight": DEFAULT_CFG_WEIGHT,
+                "temperature": DEFAULT_TEMPERATURE
+            }
+
+            future = executor.submit(
+                process_one_chunk,
+                i, chunk_data['text'], text_chunks_dir, audio_chunks_dir,
+                voice_path, chunk_tts_params, start_time, total_chunks,
+                punc_norm, book_name, log_run, log_path, device,
+                model, None, chunk_data['is_paragraph_end'], all_chunks, chunk_data['boundary_type']
+            )
+            futures.append(future)
+
+        for future in as_completed(futures):
+            try:
+                result = future.result()
+                if result:
+                    idx, _ = result
+                    log_chunk_progress(idx, total_chunks, start_time, 0)
+            except Exception as e:
+                print(f"\n❌ An error occurred while processing a chunk: {e}")
+
+    elapsed_time = time.time() - start_time
+    print(f"\n{GREEN}✅ Generation Complete!{RESET}")
+    print(f"⏱️ Total time: {timedelta(seconds=int(elapsed_time))}")
+    print(f"🔊 Audio chunks are in: {audio_chunks_dir}")
+    print("You can now use Option 3 from the main menu to combine them.")
+
+if __name__ == "__main__":
+    main()

utils/prechunktest.TXT

@@ -0,0 +1,4 @@
+from chunk_manager import prechunk_text_file, save_chunks_to_json
+
+chunks = prechunk_text_file("/home/danno/MyApps/chatterbox/Text_Input/test.txt", max_words=30, min_words=4)
+save_chunks_to_json(chunks, "Text_Input/my_book_chunks.json")

utils/resume_handler.TXT

@@ -0,0 +1,525 @@
+"""
+Resume Handler Module
+Handles resume functionality for interrupted processing
+"""
+
+import torch
+import time
+import logging
+from datetime import timedelta
+from pathlib import Path
+
+from config import *
+from modules.text_processor import smart_punctuate, sentence_chunk_text
+from modules.file_manager import (
+    setup_book_directories, find_book_files, list_voice_samples,
+    ensure_voice_sample_compatibility, get_audio_files_in_directory,
+    combine_audio_chunks, convert_to_m4b, add_metadata_to_m4b
+)
+from modules.audio_processor import get_chunk_audio_duration, pause_for_chunk_review
+from modules.progress_tracker import setup_logging, log_chunk_progress, log_run
+
+def analyze_existing_chunks(audio_chunks_dir):
+    """Analyze existing chunks to determine resume point"""
+    if not audio_chunks_dir.exists():
+        return 0, []
+
+    chunk_paths = get_audio_files_in_directory(audio_chunks_dir)
+
+    if not chunk_paths:
+        return 0, []
+
+    # Find the highest chunk number
+    chunk_numbers = []
+    for chunk_path in chunk_paths:
+        import re
+        match = re.match(r"chunk_(\d+)\.wav", chunk_path.name)
+        if match:
+            chunk_numbers.append(int(match.group(1)))
+
+    if not chunk_numbers:
+        return 0, []
+
+    chunk_numbers.sort()
+    last_chunk_number = max(chunk_numbers)
+
+    # Check for gaps in sequence
+    missing_chunks = []
+    for i in range(1, last_chunk_number + 1):
+        if i not in chunk_numbers:
+            missing_chunks.append(i)
+
+    print(f"📊 Existing chunks analysis:")
+    print(f"   Total chunks found: {GREEN}{len(chunk_numbers)}{RESET}")
+    print(f"   Highest chunk number: {GREEN}{last_chunk_number}{RESET}")
+    if missing_chunks:
+        print(f"   Missing chunks: {YELLOW}{len(missing_chunks)}{RESET}")
+        if len(missing_chunks) <= 10:
+            print(f"   Missing: {missing_chunks}")
+        else:
+            print(f"   Missing: {missing_chunks[:10]}... (+{len(missing_chunks)-10} more)")
+
+    return last_chunk_number, missing_chunks
+
+def suggest_resume_point(last_chunk, missing_chunks):
+    """Suggest optimal resume point based on existing chunks"""
+    if not missing_chunks:
+        # No gaps, can resume from next chunk
+        return last_chunk + 1
+
+    # If there are missing chunks, suggest resuming from first missing
+    first_missing = min(missing_chunks)
+
+    print(f"\n💡 Resume suggestions:")
+    print(f"   Resume from chunk {GREEN}{last_chunk + 1}{RESET} (continue from last)")
+    print(f"   Resume from chunk {YELLOW}{first_missing}{RESET} (fill gaps first)")
+
+    return first_missing
+
+def validate_resume_point(start_chunk, total_expected_chunks):
+    """Validate that resume point makes sense"""
+    if start_chunk < 1:
+        print(f"{RED}❌ Invalid resume point: {start_chunk}. Must be >= 1{RESET}")
+        return False
+
+    if start_chunk > total_expected_chunks:
+        print(f"{RED}❌ Resume point {start_chunk} exceeds expected total chunks {total_expected_chunks}{RESET}")
+        return False
+
+    return True
+
+def process_book_folder_resume(book_dir, voice_path, tts_params, device, start_chunk=1):
+    """Enhanced book processing with resume capability"""
+    from modules.tts_engine import process_one_chunk, load_optimized_model, get_optimal_workers
+    from chatterbox.tts import punc_norm
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+
+    # Setup directories
+    output_root, tts_dir, text_chunks_dir, audio_chunks_dir = setup_book_directories(book_dir)
+
+    # Find book files
+    text_files, cover_file, nfo_file = find_book_files(book_dir)
+
+    if not text_files:
+        logging.info(f"[{book_dir.name}] ERROR: No .txt files found in the book folder.")
+        return None, None, []
+
+    # Don't delete existing directories if resuming
+    if start_chunk == 1:
+        # Only clear on fresh start
+        import shutil
+        for d in [text_chunks_dir, audio_chunks_dir]:
+            if d.exists() and d.is_dir():
+                shutil.rmtree(d)
+
+        for d in [output_root, tts_dir, text_chunks_dir, audio_chunks_dir]:
+            d.mkdir(parents=True, exist_ok=True)
+    else:
+        # Ensure directories exist for resume
+        for d in [output_root, tts_dir, text_chunks_dir, audio_chunks_dir]:
+            d.mkdir(parents=True, exist_ok=True)
+
+    setup_logging(output_root)
+
+    # Enhanced text processing
+    all_chunks = []
+    for tf in text_files:
+        with open(tf, 'r', encoding='utf-8') as f:
+            raw = f.read()
+        smart = smart_punctuate(raw)
+        chunks = sentence_chunk_text(smart, max_words=MAX_CHUNK_WORDS, min_words=MIN_CHUNK_WORDS)
+        for chunk_text, is_para_end in chunks:
+            all_chunks.append({
+                "text": chunk_text,
+                "is_paragraph_end": is_para_end
+            })
+
+    # Validate resume point
+    if not validate_resume_point(start_chunk, len(all_chunks)):
+        return None, None, []
+
+    # Filter chunks to process (resume logic)
+    if start_chunk > 1:
+        print(f"🔄 Resuming from chunk {start_chunk}")
+        print(f"📊 Skipping chunks 1-{start_chunk-1} (already completed)")
+
+        # Check which chunks already exist
+        existing_chunks = []
+        for i in range(start_chunk-1):
+            chunk_path = audio_chunks_dir / f"chunk_{i+1:05}.wav"
+            if chunk_path.exists():
+                existing_chunks.append(i+1)
+
+        print(f"✅ Found {len(existing_chunks)} existing chunks")
+
+        # Only process remaining chunks
+        chunks_to_process = all_chunks[start_chunk-1:]
+        chunk_offset = start_chunk - 1
+    else:
+        chunks_to_process = all_chunks
+        chunk_offset = 0
+
+    run_log_lines = [
+        f"\n===== RESUME Processing: {book_dir.name} =====",
+        f"Voice: {voice_path.name}",
+        f"Started: {time.strftime('%Y-%m-%d %H:%M:%S')}",
+        f"Resume from chunk: {start_chunk}",
+        f"Text files processed: {len(text_files)}",
+        f"Total chunks generated: {len(all_chunks)}",
+        f"Chunks to process: {len(chunks_to_process)}"
+    ]
+
+    # Write initial run info immediately
+    initial_log = run_log_lines + [
+        f"--- Generation Settings ---",
+        f"Batch Processing: Enabled ({BATCH_SIZE} chunks per batch)",
+        f"ASR Enabled: {ENABLE_ASR}",
+        f"Hum Detection: {ENABLE_HUM_DETECTION}",
+        f"Dynamic Workers: {USE_DYNAMIC_WORKERS}",
+        f"Voice used: {voice_path.name}",
+        f"Exaggeration: {tts_params['exaggeration']}",
+        f"CFG weight: {tts_params['cfg_weight']}",
+        f"Temperature: {tts_params['temperature']}",
+        f"Processing Status: IN PROGRESS...",
+        f"="*50
+    ]
+
+    log_run("\n".join(initial_log), output_root / "run.log")
+    print(f"📝 Initial run info written to: {output_root / 'run.log'}")
+
+    start_time = time.time()
+    total_chunks = len(all_chunks)
+    remaining_chunks = len(chunks_to_process)
+    log_path = output_root / "chunk_validation.log"
+
+    # Calculate existing audio duration for accurate progress
+    total_audio_duration = 0.0
+    if start_chunk > 1:
+        print("📊 Calculating existing audio duration...")
+        for i in range(start_chunk-1):
+            chunk_path = audio_chunks_dir / f"chunk_{i+1:05}.wav"
+            if chunk_path.exists():
+                total_audio_duration += get_chunk_audio_duration(chunk_path)
+        print(f"📊 Existing audio: {timedelta(seconds=int(total_audio_duration))}")
+
+    # Batch processing for remaining chunks
+    print(f"📊 Processing {remaining_chunks} remaining chunks in batches of {BATCH_SIZE}")
+
+    all_results = []
+
+    for batch_start in range(0, remaining_chunks, BATCH_SIZE):
+        batch_end = min(batch_start + BATCH_SIZE, remaining_chunks)
+        batch_chunks = chunks_to_process[batch_start:batch_end]
+
+        actual_start_chunk = chunk_offset + batch_start + 1
+        actual_end_chunk = chunk_offset + batch_end
+
+        print(f"\n🔄 Processing batch: chunks {actual_start_chunk}-{actual_end_chunk}")
+
+        # Fresh model for each batch
+        model = load_optimized_model(device)
+        compatible_voice = ensure_voice_sample_compatibility(voice_path, output_dir=tts_dir)
+        model.prepare_conditionals(compatible_voice, exaggeration=tts_params['exaggeration'])
+
+        # Load ASR model once per batch if needed
+        asr_model = None
+        if ENABLE_ASR:
+            import whisper
+            print(f"🎤 Loading Whisper ASR model for batch...")
+            asr_model = whisper.load_model("base", device="cuda")
+
+        futures = []
+        batch_results = []
+
+        # Dynamic worker allocation
+        optimal_workers = get_optimal_workers()
+        print(f"🔧 Using {optimal_workers} workers for batch {actual_start_chunk}-{actual_end_chunk}")
+
+        with ThreadPoolExecutor(max_workers=optimal_workers) as executor:
+            for i, chunk_data in enumerate(batch_chunks):
+                global_chunk_index = chunk_offset + batch_start + i
+
+                # Check for shutdown request
+                if shutdown_requested:
+                    print(f"\n⏹️ {YELLOW}Stopping submission of new chunks...{RESET}")
+                    break
+
+                chunk = chunk_data["text"]
+                is_paragraph_end = chunk_data.get("is_paragraph_end", False)
+                all_chunk_texts = [cd["text"] for cd in all_chunks]
+
+                futures.append(executor.submit(
+                    process_one_chunk,
+                    global_chunk_index, chunk, text_chunks_dir, audio_chunks_dir,
+                    voice_path, tts_params, start_time, total_chunks,
+                    punc_norm, book_dir.name, log_run, log_path, device,
+                    model, asr_model, is_paragraph_end, all_chunk_texts
+                ))
+
+            # Wait for batch to complete
+            print(f"🔄 {CYAN}Waiting for batch {actual_start_chunk}-{actual_end_chunk} to complete...{RESET}")
+            completed_count = 0
+
+            for fut in as_completed(futures):
+                try:
+                    idx, wav_path = fut.result()
+                    if wav_path and wav_path.exists():
+                        # Measure actual audio duration for this chunk
+                        chunk_duration = get_chunk_audio_duration(wav_path)
+                        total_audio_duration += chunk_duration
+                        batch_results.append((idx, wav_path))
+
+                        # Update progress every 10 chunks within batch
+                        completed_count += 1
+                        if completed_count % 10 == 0:
+                            current_chunk = chunk_offset + batch_start + completed_count
+                            log_chunk_progress(current_chunk - 1, total_chunks, start_time, total_audio_duration)
+
+                except Exception as e:
+                    logging.error(f"Future failed in batch: {e}")
+
+        # Clean up model after batch
+        print(f"🧹 Cleaning up after batch {actual_start_chunk}-{actual_end_chunk}")
+        del model
+        if asr_model:
+            del asr_model
+        torch.cuda.empty_cache()
+        import gc
+        gc.collect()
+        time.sleep(2)
+
+        all_results.extend(batch_results)
+        print(f"✅ Batch {actual_start_chunk}-{actual_end_chunk} completed ({len(batch_results)} chunks)")
+
+    # Final processing - combine ALL chunks (existing + new)
+    quarantine_dir = audio_chunks_dir / "quarantine"
+    pause_for_chunk_review(quarantine_dir)
+
+    # Collect ALL chunk paths (both existing and newly created)
+    chunk_paths = []
+    for i in range(total_chunks):
+        chunk_path = audio_chunks_dir / f"chunk_{i+1:05}.wav"
+        if chunk_path.exists():
+            chunk_paths.append(chunk_path)
+        else:
+            logging.warning(f"Missing chunk file: chunk_{i+1:05}.wav")
+
+    if not chunk_paths:
+        logging.info(f"{RED}❌ No valid audio chunks found. Skipping concatenation and conversion.{RESET}")
+        return None, None, []
+
+    print(f"📊 Found {len(chunk_paths)} total chunks for final audiobook")
+
+    # Calculate timing
+    elapsed_total = time.time() - start_time
+    elapsed_td = timedelta(seconds=int(elapsed_total))
+
+    # Get total audio duration from ALL chunks
+    total_audio_duration_final = sum(get_chunk_audio_duration(chunk_path) for chunk_path in chunk_paths)
+    audio_duration_td = timedelta(seconds=int(total_audio_duration_final))
+    realtime_factor = total_audio_duration_final / elapsed_total if elapsed_total > 0 else 0.0
+
+    print(f"\n⏱️ Resume Processing Complete:")
+    print(f"   Elapsed Time: {CYAN}{str(elapsed_td)}{RESET}")
+    print(f"   Audio Duration: {GREEN}{str(audio_duration_td)}{RESET}")
+    print(f"   Realtime Factor: {YELLOW}{realtime_factor:.2f}x{RESET}")
+
+    # Combine audio
+    combined_wav_path = output_root / f"{book_dir.name} [{voice_path.stem}].wav"
+    print("\n💾 Saving WAV file...")
+    combine_audio_chunks(chunk_paths, combined_wav_path)
+
+    # M4B conversion
+    temp_m4b_path = output_root / "output.m4b"
+    final_m4b_path = output_root / f"{book_dir.name}[{voice_path.stem}].m4b"
+    convert_to_m4b(combined_wav_path, temp_m4b_path)
+    add_metadata_to_m4b(temp_m4b_path, final_m4b_path, cover_file, nfo_file)
+
+    logging.info(f"Audiobook created: {final_m4b_path}")
+
+    # Append final completion info
+    completion_log = [
+        f"\n--- Resume Processing Complete ---",
+        f"Completed: {time.strftime('%Y-%m-%d %H:%M:%S')}",
+        f"Processing Time: {str(elapsed_td)}",
+        f"Audio Duration: {str(audio_duration_td)}",
+        f"Realtime Factor: {realtime_factor:.2f}x",
+        f"Total Chunks: {len(chunk_paths)}",
+        f"Combined WAV: {combined_wav_path}",
+        f"Final M4B: {final_m4b_path}"
+    ]
+
+    # Append to existing log
+    log_run("\n".join(completion_log), output_root / "run.log")
+    print(f"📝 Final completion info appended to: {output_root / 'run.log'}")
+
+    return final_m4b_path, combined_wav_path, run_log_lines
+
+def resume_book_from_chunk(start_chunk):
+    """Interactive resume function for stuck book"""
+    print(f"\n🔄 Resume Book Processing from Chunk {start_chunk}")
+    print("=" * 50)
+
+    # Show available books
+    book_dirs = sorted([d for d in TEXT_INPUT_ROOT.iterdir() if d.is_dir()])
+    if not book_dirs:
+        print(f"{RED}No folders found in Text_Input/.{RESET}")
+        return None
+
+    print("Available books:")
+    for i, book in enumerate(book_dirs):
+        # Check if book has existing processing
+        audiobook_dir = AUDIOBOOK_ROOT / book.name
+        if audiobook_dir.exists():
+            audio_chunks_dir = audiobook_dir / "TTS" / "audio_chunks"
+            if audio_chunks_dir.exists():
+                last_chunk, missing = analyze_existing_chunks(audio_chunks_dir)
+                status = f"(last chunk: {last_chunk})"
+            else:
+                status = "(no existing chunks)"
+        else:
+            status = "(not started)"
+
+        print(f"  [{i}] {book.name} {status}")
+
+    while True:
+        try:
+            book_idx = int(input("Select book index: "))
+            if 0 <= book_idx < len(book_dirs):
+                book_dir = book_dirs[book_idx]
+                break
+        except Exception:
+            pass
+        print("Invalid selection. Try again.")
+
+    # Analyze existing chunks for selected book
+    audiobook_dir = AUDIOBOOK_ROOT / book_dir.name
+    if audiobook_dir.exists():
+        audio_chunks_dir = audiobook_dir / "TTS" / "audio_chunks"
+        if audio_chunks_dir.exists():
+            last_chunk, missing = analyze_existing_chunks(audio_chunks_dir)
+            suggested_resume = suggest_resume_point(last_chunk, missing)
+
+            print(f"\nSuggested resume point: {GREEN}{suggested_resume}{RESET}")
+
+            # Allow user to override
+            user_input = input(f"Resume from chunk [{suggested_resume}]: ").strip()
+            if user_input:
+                try:
+                    start_chunk = int(user_input)
+                except ValueError:
+                    print(f"Invalid input, using suggested: {suggested_resume}")
+                    start_chunk = suggested_resume
+            else:
+                start_chunk = suggested_resume
+
+    # Show available voices
+    voice_files = list_voice_samples()
+    if not voice_files:
+        print(f"{RED}No voice samples found.{RESET}")
+        return None
+
+    print("\nAvailable voices:")
+    for i, voice in enumerate(voice_files):
+        print(f"  [{i}] {voice.name}")
+
+    while True:
+        try:
+            voice_idx = int(input("Select voice index: "))
+            if 0 <= voice_idx < len(voice_files):
+                voice_path = voice_files[voice_idx]
+                break
+        except Exception:
+            pass
+        print("Invalid selection. Try again.")
+
+    # Get TTS parameters
+    def prompt_float(prompt, default):
+        val = input(f"{prompt} [{default}]: ").strip()
+        return float(val) if val else default
+
+    exaggeration = prompt_float("Enter exaggeration (emotion intensity)", 0.5)
+    cfg_weight = prompt_float("Enter cfg_weight (faithfulness to text)", 0.2)
+    temperature = prompt_float("Enter temperature (randomness)", 0.2)
+
+    tts_params = dict(exaggeration=exaggeration, cfg_weight=cfg_weight, temperature=temperature)
+
+    # Determine device
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available():
+        device = "mps"
+    else:
+        device = "cpu"
+
+    print(f"\n🚀 Resuming {book_dir.name} from chunk {start_chunk}")
+    print(f"🎤 Voice: {voice_path.name}")
+    print(f"⚙️ Parameters: {tts_params}")
+
+    # Process with resume
+    return process_book_folder_resume(book_dir, voice_path, tts_params, device, start_chunk)
+
+def find_incomplete_books():
+    """Find books that appear to be incomplete"""
+    incomplete_books = []
+
+    for book_dir in TEXT_INPUT_ROOT.iterdir():
+        if not book_dir.is_dir():
+            continue
+
+        audiobook_dir = AUDIOBOOK_ROOT / book_dir.name
+        if not audiobook_dir.exists():
+            continue
+
+        audio_chunks_dir = audiobook_dir / "TTS" / "audio_chunks"
+        if not audio_chunks_dir.exists():
+            continue
+
+        # Check if there's a final M4B
+        m4b_files = list(audiobook_dir.glob("*.m4b"))
+        wav_files = list(audiobook_dir.glob("*.wav"))
+
+        if not m4b_files and not wav_files:
+            # No final output, likely incomplete
+            last_chunk, missing = analyze_existing_chunks(audio_chunks_dir)
+            if last_chunk > 0:
+                incomplete_books.append({
+                    "name": book_dir.name,
+                    "last_chunk": last_chunk,
+                    "missing_chunks": len(missing),
+                    "path": book_dir
+                })
+
+    return incomplete_books
+
+def auto_resume_incomplete():
+    """Automatically suggest resume for incomplete books"""
+    incomplete = find_incomplete_books()
+
+    if not incomplete:
+        print(f"{GREEN}✅ No incomplete books found!{RESET}")
+        return
+
+    print(f"{YELLOW}📋 Found {len(incomplete)} incomplete books:{RESET}")
+    for i, book in enumerate(incomplete):
+        print(f"  [{i}] {book['name']} (last chunk: {book['last_chunk']}, missing: {book['missing_chunks']})")
+
+    choice = input(f"\nSelect book to resume [0-{len(incomplete)-1}] or 'q' to quit: ").strip()
+
+    if choice.lower() == 'q':
+        return
+
+    try:
+        idx = int(choice)
+        if 0 <= idx < len(incomplete):
+            selected_book = incomplete[idx]
+            suggested_resume = selected_book['last_chunk'] + 1
+
+            print(f"\n🎯 Selected: {selected_book['name']}")
+            print(f"💡 Suggested resume point: chunk {suggested_resume}")
+
+            return resume_book_from_chunk(suggested_resume)
+    except ValueError:
+        print("Invalid selection.")
+
+    return None

utils/text_cleaner.TXT

@@ -0,0 +1,29 @@
+# text_cleaner.py
+
+import re
+
+def smart_punctuate(text):
+    """Basic punctuation cleanup for sentence ends"""
+    lines = text.splitlines()
+    out = []
+
+    for l in lines:
+        stripped = l.strip()
+
+        # Preserve empty lines (paragraph breaks)
+        if not stripped:
+            out.append("")
+        elif not re.search(r'[.!?]$', stripped):
+            out.append(stripped + ".")
+        else:
+            out.append(stripped)
+
+    result = "\n".join(out)
+
+    # Normalize quotes and formatting
+    result = result.replace('"', '"').replace('“', '"').replace('”', '"')
+    result = result.replace('‘', "'").replace('’', "'")
+    result = re.sub(r'\*\*([^*]+)\*\*', r'\1', result)  # remove markdown bold
+    result = re.sub(r'_{2,}', '', result)  # remove underlines
+
+    return result

utils/text_processor.TXT

@@ -0,0 +1,449 @@
+"""
+Text Processing Module
+Handles text chunking, abbreviations, and preprocessing for TTS
+"""
+
+import re
+import logging
+from pathlib import Path
+from config import *
+
+# ============================================================================
+# ABBREVIATION REPLACEMENT SYSTEM
+# ============================================================================
+
+def load_abbreviations(file_path="abbreviations.txt"):
+    """Load abbreviation replacements from external file"""
+    replacements = {}
+    abbrev_file = Path(file_path)
+
+    if not abbrev_file.exists():
+        print(f"⚠️ {YELLOW}Abbreviations file not found: {file_path}{RESET}")
+        print(f"📝 Creating sample file...")
+        create_sample_abbreviations_file(abbrev_file)
+        return replacements
+
+    try:
+        with open(abbrev_file, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                line = line.strip()
+
+                # Skip empty lines and comments
+                if not line or line.startswith('#'):
+                    continue
+
+                # Parse "abbrev -> replacement" format
+                if ' -> ' in line:
+                    abbrev, replacement = line.split(' -> ', 1)
+                    replacements[abbrev.strip()] = replacement.strip()
+                else:
+                    print(f"⚠️ Invalid format on line {line_num}: {line}")
+
+        print(f"✅ Loaded {len(replacements)} abbreviation replacements from {file_path}")
+
+    except Exception as e:
+        print(f"❌ Error loading abbreviations: {e}")
+
+    return replacements
+
+def create_sample_abbreviations_file(file_path):
+    """Create a sample abbreviations file with common replacements"""
+    sample_content = """# Abbreviation Replacements for TTS
+# Format: abbreviation -> replacement
+# Lines starting with # are comments
+
+# Common titles and abbreviations
+Dr. -> Doctor
+Mr. -> Mister
+Mrs. -> Missus
+Ms. -> Miss
+Prof. -> Professor
+Rev. -> Reverend
+Lt. -> Lieutenant
+Capt. -> Captain
+Gen. -> General
+Col. -> Colonel
+Jr. -> Junior
+Sr. -> Senior
+
+# Political and organizations
+M.P. -> MP
+U.S. -> US
+U.K. -> UK
+U.N. -> UN
+F.B.I. -> FBI
+C.I.A. -> CIA
+N.A.S.A. -> NASA
+
+# Common abbreviations
+etc. -> et cetera
+vs. -> versus
+e.g. -> for example
+i.e. -> that is
+Inc. -> Incorporated
+Corp. -> Corporation
+Ltd. -> Limited
+Co. -> Company
+
+# Numbers and ordinals
+1st -> first
+2nd -> second
+3rd -> third
+4th -> fourth
+5th -> fifth
+10th -> tenth
+20th -> twentieth
+21st -> twenty-first
+30th -> thirtieth
+40th -> fortieth
+50th -> fiftieth
+60th -> sixtieth
+70th -> seventieth
+80th -> eightieth
+90th -> ninetieth
+100th -> one hundredth
+
+# Time abbreviations
+a.m. -> AM
+p.m. -> PM
+A.M. -> AM
+P.M. -> PM
+"""
+
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(sample_content)
+        print(f"📝 Created sample abbreviations file: {file_path}")
+        print(f"💡 Edit this file to add your own replacements!")
+    except Exception as e:
+        print(f"❌ Error creating sample file: {e}")
+
+def preprocess_abbreviations(text, replacements):
+    """Replace abbreviations with TTS-friendly versions"""
+    if not replacements:
+        return text
+
+    original_text = text
+    replacements_made = 0
+
+    # Apply replacements (order matters for overlapping patterns)
+    for abbrev, replacement in replacements.items():
+        if abbrev in text:
+            text = text.replace(abbrev, replacement)
+            replacements_made += 1
+
+    if replacements_made > 0:
+        logging.info(f"📝 Applied {replacements_made} abbreviation replacements")
+
+    return text
+
+# ============================================================================
+# TEXT PREPROCESSING AND CHUNKING
+# ============================================================================
+
+def smart_punctuate(text):
+    """Enhanced punctuation normalization with abbreviation replacement"""
+
+    # Load abbreviations and apply them
+    abbreviation_replacements = load_abbreviations()
+    text = preprocess_abbreviations(text, abbreviation_replacements)
+
+    # Then continue with existing punctuation logic
+    lines = text.splitlines()
+    out = []
+
+    for l in lines:
+        stripped = l.strip()
+
+        # Preserve empty lines (paragraph breaks)
+        if not stripped:
+            out.append("")  # Keep the blank line
+        # Process non-empty lines
+        elif not re.search(r'[.!?]$', stripped):
+            out.append(stripped + ".")
+        else:
+            out.append(stripped)
+
+    result = "\n".join(out)
+
+    # Enhanced text preprocessing - use simple string replacements
+    result = result.replace('"', '"').replace('"', '"')  # Replace smart double quotes
+    result = result.replace(''', "'").replace(''', "'")  # Replace smart single quotes
+
+    # Remove problematic formatting
+    result = re.sub(r'\*\*([^*]+)\*\*', r'\1', result)  # Remove bold markdown
+    result = re.sub(r'_{2,}', '', result)  # Remove underlines
+
+    return result
+
+def fix_short_sentence_artifacts(chunk_text):
+    """
+    Fix multiple short sentences that cause TTS errors.
+    Example: "Yes. No. Maybe." → "Yes, no, maybe."
+             "Right." → "Right," (if it's a single-word chunk)
+    """
+    # Handle full chunk that is just one short sentence
+    words = chunk_text.strip().split()
+    if len(words) == 1 and chunk_text.strip().endswith('.'):
+        return chunk_text.strip()[:-1] + ','  # Replace period with comma
+
+    parts = re.split(r'([.!?])', chunk_text.strip())
+    if len(parts) < 2:
+        return chunk_text  # nothing to fix
+
+    # Reconstruct sentence-punctuation pairs
+    sentences = []
+    for i in range(0, len(parts)-1, 2):
+        sentence = parts[i].strip()
+        punct = parts[i+1]
+        if sentence:
+            word_count = len(sentence.split())
+            sentences.append((sentence, punct, word_count))
+
+    # Handle multiple short sentences
+    short_count = sum(1 for _, _, wc in sentences if wc <= 3)
+
+    if short_count >= 2 and len(sentences) >= 2:
+        merged = ", ".join(s for s, _, _ in sentences) + "."
+        return merged
+
+    # Handle case where first sentence is a single word
+    if len(sentences) >= 2 and sentences[0][2] == 1 and sentences[0][1] == ".":
+        # Replace period with comma
+        first, second = sentences[0][0], sentences[1][0]
+        rest = " ".join(s for s, _, _ in sentences[2:])
+        new_text = f"{first}, {second}"
+        if rest:
+            new_text += " " + rest
+        return new_text
+
+    return chunk_text
+
+def sentence_chunk_text(text, max_words=MAX_CHUNK_WORDS, min_words=MIN_CHUNK_WORDS):
+    """Enhanced sentence chunking with smart mid-sentence breaking for long sentences"""
+
+    # First, split into sentences
+    sentence_end_re = re.compile(r'([.!?][\"\'\)]*\s+)')
+    sentences = []
+    start_index = 0
+
+    for match in sentence_end_re.finditer(text):
+        end_index = match.end()
+        sentence = text[start_index:end_index].strip()
+        if sentence:
+            sentences.append(sentence)
+        start_index = end_index
+
+    if start_index < len(text):
+        remainder = text[start_index:].strip()
+        if remainder:
+            sentences.append(remainder)
+
+    # Process each sentence and break if too long
+    processed_chunks = []
+
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if not sentence:
+            continue
+
+        # Check if sentence exceeds word limit
+        sentence_words = sentence.split()
+
+        if len(sentence_words) <= max_words:
+            # Sentence is fine as-is
+            is_para_end = sentence.endswith("\n") or sentence.endswith("\n\n")
+            processed_chunks.append((sentence, is_para_end))
+        else:
+            # Sentence is too long - need to break it intelligently
+            broken_chunks = break_long_sentence(sentence, max_words)
+            processed_chunks.extend(broken_chunks)
+
+    # Now group short chunks together (original grouping logic)
+    final_chunks = []
+    short_group = []
+
+    for chunk_text, is_para_end in processed_chunks:
+        word_count = len(chunk_text.split())
+
+        if word_count < min_words and not is_para_end:
+            # Collect short chunks for grouping
+            short_group.append(re.sub(r'[.!?]+$', '', chunk_text.strip()))
+        else:
+            # Process any accumulated short chunks
+            if short_group:
+                if word_count < min_words:
+                    # This chunk is also short, add it to the group
+                    short_group.append(re.sub(r'[.!?]+$', '', chunk_text.strip()))
+                    merged = ", ".join(short_group) + "."
+                    final_chunks.append((merged.strip(), is_para_end))
+                    short_group = []
+                else:
+                    # Merge short group with current chunk
+                    merged = ", ".join(short_group) + ", " + chunk_text
+                    final_chunks.append((merged.strip(), is_para_end))
+                    short_group = []
+            else:
+                # Normal chunk
+                final_chunks.append((chunk_text, is_para_end))
+
+    # Handle any remaining short group
+    if short_group:
+        merged = ", ".join(short_group) + "."
+        final_chunks.append((merged.strip(), False))
+
+    # Apply short sentence cleanup
+    fixed_chunks = []
+    for chunk_text, is_para_end in final_chunks:
+        fixed_text = fix_short_sentence_artifacts(chunk_text)
+        fixed_chunks.append((fixed_text, is_para_end))
+
+    return fixed_chunks
+
+def break_long_sentence(sentence, max_words):
+    """Break a long sentence at natural pause points"""
+
+    # Define break points in order of preference
+    break_patterns = [
+        r'(,\s+and\s+)',           # ", and "
+        r'(,\s+but\s+)',           # ", but "
+        r'(,\s+yet\s+)',           # ", yet "
+        r'(,\s+or\s+)',            # ", or "
+        r'(,\s+so\s+)',            # ", so "
+        r'(;\s*)',                 # "; "
+        r'(—\s*)',                 # "— " (em dash)
+        r'(\s+—\s+)',              # " — " (spaced em dash)
+        r'(\.\s*")',               # '." ' (end quote)
+        r'("\s*)',                 # '" ' (start quote)
+        r'(,\s+which\s+)',         # ", which "
+        r'(,\s+when\s+)',          # ", when "
+        r'(,\s+where\s+)',         # ", where "
+        r'(,\s+while\s+)',         # ", while "
+        r'(,\s+though\s+)',        # ", though "
+        r'(,\s+)',                 # ", " (any comma - last resort)
+    ]
+
+    chunks = []
+    remaining_text = sentence.strip()
+    is_para_end = sentence.endswith("\n") or sentence.endswith("\n\n")
+
+    while remaining_text:
+        words = remaining_text.split()
+
+        if len(words) <= max_words:
+            # Remaining text fits in one chunk
+            chunks.append((remaining_text.strip(), is_para_end if not chunks else False))
+            break
+
+        # Find the best break point within the word limit
+        best_break_pos = None
+        best_break_text = ""
+
+        # Try each break pattern
+        for pattern in break_patterns:
+            for match in re.finditer(pattern, remaining_text):
+                break_pos = match.end()
+
+                # Check if this break point gives us a good chunk size
+                potential_chunk = remaining_text[:break_pos].strip()
+                chunk_words = potential_chunk.split()
+
+                if len(chunk_words) <= max_words and len(chunk_words) >= min(6, max_words // 3):
+                    best_break_pos = break_pos
+                    best_break_text = potential_chunk
+                    break
+
+            if best_break_pos:
+                break
+
+        if best_break_pos:
+            # Found a good break point
+            chunks.append((best_break_text, False))
+            remaining_text = remaining_text[best_break_pos:].strip()
+        else:
+            # No good break point found - force break at word limit
+            words = remaining_text.split()
+            force_break_words = words[:max_words]
+            force_break_text = " ".join(force_break_words)
+
+            # Try to end at a reasonable point
+            if not force_break_text.endswith(('.', '!', '?', ',', ';')):
+                force_break_text += ","
+
+            chunks.append((force_break_text, False))
+            remaining_text = " ".join(words[max_words:]).strip()
+
+    return chunks
+
+# ============================================================================
+# CONTENT BOUNDARY DETECTION
+# ============================================================================
+
+def detect_content_boundaries(chunk_text, chunk_index, all_chunks):
+    """Detect chapter breaks and paragraph endings for appropriate silence"""
+    boundary_type = None
+
+    # Chapter detection (flexible patterns)
+    chapter_patterns = [
+        r'^(Chapter \d+|CHAPTER \d+)',
+        r'^(Ch\. \d+|CH\. \d+)',
+        r'^\d+\.',  # Simple "1." numbering
+        r'^[IVX]+\.',  # Roman numerals "I.", "II.", etc.
+    ]
+
+    for pattern in chapter_patterns:
+        if re.search(pattern, chunk_text.strip(), re.MULTILINE):
+            boundary_type = "chapter_start"
+            break
+
+    # Look ahead for chapter start (current chunk ends chapter)
+    if chunk_index + 1 < len(all_chunks):
+        next_chunk = all_chunks[chunk_index + 1]
+        for pattern in chapter_patterns:
+            if re.search(pattern, next_chunk.strip()):
+                boundary_type = "chapter_end"
+                break
+
+    # Section breaks (asterisks, multiple line breaks)
+    if re.search(r'\*{3,}|\#{3,}|—{3,}', chunk_text):
+        boundary_type = "section_break"
+
+    # Paragraph ending (already detected in chunking)
+    if chunk_text.endswith('\n\n') or chunk_text.endswith('\n'):
+        if boundary_type is None:
+            boundary_type = "paragraph_end"
+
+    return boundary_type
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
+def reload_abbreviations():
+    """Reload abbreviations from file (useful for testing changes)"""
+    return load_abbreviations()
+
+def test_abbreviations(test_text="Dr. Smith met with the M.P. at 3:30 p.m. on the 21st."):
+    """Test abbreviation replacements on sample text"""
+    abbreviation_replacements = load_abbreviations()
+    print(f"Original: {test_text}")
+    processed = preprocess_abbreviations(test_text, abbreviation_replacements)
+    print(f"Processed: {processed}")
+    return processed
+
+def test_chunking(test_text=None, max_words=20, min_words=4):
+    """Test the enhanced chunking with sample or custom text"""
+    if test_text is None:
+        test_text = '''Though perfectly worldly-wise, and able, as she expressed it, to take care of herself, there was yet something curiously ingenuous in her single-minded attitude towards life, and her whole-hearted determination to "make good." This glimpse of a world unknown to me was not without its charm, and I enjoyed seeing her vivid little face light up as she talked.'''
+
+    chunks = sentence_chunk_text(test_text, max_words=max_words, min_words=min_words)
+
+    print("Enhanced Chunking Results:")
+    for i, (chunk, is_para) in enumerate(chunks):
+        word_count = len(chunk.split())
+        print(f"Chunk {i+1} ({word_count} words): {chunk}")
+        if word_count > max_words:
+            print(f"  ⚠️ WARNING: Still over limit!")
+        print()
+
+    return chunks

wrapper/chunk_editor.py

@@ -0,0 +1,8 @@
+def update_chunk(chunk, boundary_type=None, pause_duration=None, sentiment_score=None):
+    if boundary_type is not None:
+        chunk['boundary_type'] = boundary_type
+    if pause_duration is not None:
+        chunk['pause_duration'] = pause_duration
+    if sentiment_score is not None:
+        chunk['sentiment_score'] = sentiment_score
+    return chunk

wrapper/chunk_editor.py.bak

@@ -0,0 +1,8 @@
+def update_chunk(chunk, boundary_type=None, pause_duration=None, sentiment_score=None):
+    if boundary_type is not None:
+        chunk['boundary_type'] = boundary_type
+    if pause_duration is not None:
+        chunk['pause_duration'] = pause_duration
+    if sentiment_score is not None:
+        chunk['sentiment_score'] = sentiment_score
+    return chunk

wrapper/chunk_loader.py

@@ -0,0 +1,72 @@
+import json
+
+def load_chunks(path):
+    with open(path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+        
+        # Filter out metadata entries (they start with _metadata: True)
+        if isinstance(data, list):
+            chunks = [item for item in data if not (isinstance(item, dict) and item.get('_metadata', False))]
+            return chunks
+        
+        return data
+
+def load_metadata(path):
+    """Extract metadata from JSON file"""
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        if isinstance(data, list) and data:
+            # Look for metadata in first element
+            first_item = data[0]
+            if isinstance(first_item, dict) and first_item.get('_metadata', False):
+                return first_item
+                
+    except Exception as e:
+        print(f"⚠️ Error loading metadata from {path}: {e}")
+    
+    return None
+
+def save_chunks(path, chunks):
+    # Validate and clean chunks before saving
+    from collections import OrderedDict
+    import copy
+    
+    cleaned_chunks = []
+    for chunk in chunks:
+        if isinstance(chunk, dict) and 'text' in chunk:
+            original_text = chunk['text']
+            # Clean up any quote corruption
+            cleaned_text = original_text.replace('\\"', '"').replace("\\'", "'")
+            
+            # Check for dialogue corruption patterns
+            if ('replied' in cleaned_text or 'said' in cleaned_text) and '"' in cleaned_text:
+                # Additional cleanup for dialogue
+                import re
+                cleaned_text = re.sub(r'(["\'])\s*,\s*(["\'])\s*\.', r'\1.', cleaned_text)  # Fix ", ". pattern
+                cleaned_text = re.sub(r'(["\'])\s*,\s*(["\'])\s*$', r'\1.', cleaned_text)  # Fix trailing ", "
+                
+                if cleaned_text != original_text:
+                    print(f"🔧 FIXED dialogue corruption:")
+                    print(f"   Before: {original_text}")
+                    print(f"   After:  {cleaned_text}")
+            
+            # Preserve structure (OrderedDict or regular dict)
+            if isinstance(chunk, OrderedDict):
+                chunk_copy = OrderedDict()
+                for key, value in chunk.items():
+                    if key == 'text':
+                        chunk_copy[key] = cleaned_text
+                    else:
+                        chunk_copy[key] = copy.deepcopy(value)
+            else:
+                chunk_copy = chunk.copy()
+                chunk_copy['text'] = cleaned_text
+                
+            cleaned_chunks.append(chunk_copy)
+        else:
+            cleaned_chunks.append(chunk)
+    
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(cleaned_chunks, f, indent=2, ensure_ascii=False)

wrapper/chunk_loader.py.bak

@@ -0,0 +1,9 @@
+import json
+
+def load_chunks(path):
+    with open(path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def save_chunks(path, chunks):
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(chunks, f, indent=2)

wrapper/chunk_player.py

@@ -0,0 +1,12 @@
+import subprocess
+import os
+
+def play_chunk_audio(path):
+    if not os.path.exists(path):
+        print(f"❌ Audio file not found: {path}")
+        return
+    try:
+        subprocess.run(["ffplay", "-nodisp", "-autoexit", path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except Exception as e:
+        print(f"Error playing audio: {e}")
+

wrapper/chunk_player.py.bak

@@ -0,0 +1,12 @@
+import subprocess
+import os
+
+def play_chunk_audio(path):
+    if not os.path.exists(path):
+        print(f"❌ Audio file not found: {path}")
+        return
+    try:
+        subprocess.run(["ffplay", "-nodisp", "-autoexit", path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except Exception as e:
+        print(f"Error playing audio: {e}")
+

wrapper/chunk_revisions.py

@@ -0,0 +1,34 @@
+import os
+import shutil
+from pathlib import Path
+from config.config import AUDIOBOOK_ROOT
+base = AUDIOBOOK_ROOT
+
+
+def accept_revision(index, audio_dir):
+    """
+    Archive original chunk and replace with revised version.
+    Assumes revised version is saved as: chunk_XXXXX_rev.wav
+    """
+    base = Path(audio_dir)
+    # Use 1-based indexing and 5-digit format
+    original = base / f"chunk_{index+1:05d}.wav"
+    revised = base / f"chunk_{index+1:05d}_rev.wav"
+    archive_dir = base.parent.parent / "Audio_Revisions"
+    archive_dir.mkdir(exist_ok=True)
+
+    if not revised.exists():
+        print("❌ No revised file found. Cannot accept.")
+        return
+
+    # Archive original if exists
+    if original.exists():
+        archived = archive_dir / f"chunk_{index+1:05d}_orig.wav"
+        shutil.move(str(original), str(archived))
+        print(f"📦 Original chunk archived to {archived.name}")
+    else:
+        print(f"⚠️ Original chunk missing — no archive created.")
+
+    # Move revised chunk to main filename
+    shutil.move(str(revised), str(original))
+    print(f"✅ Revised chunk accepted as {original.name}")

wrapper/chunk_revisions.py.bak

@@ -0,0 +1,34 @@
+import os
+import shutil
+from pathlib import Path
+from config.config import AUDIOBOOK_ROOT
+base = AUDIOBOOK_ROOT
+
+
+def accept_revision(index, audio_dir):
+    """
+    Archive original chunk and replace with revised version.
+    Assumes revised version is saved as: chunk_XXXXX_rev.wav
+    """
+    base = Path(audio_dir)
+    # Use 1-based indexing and 5-digit format
+    original = base / f"chunk_{index+1:05d}.wav"
+    revised = base / f"chunk_{index+1:05d}_rev.wav"
+    archive_dir = base.parent.parent / "Audio_Revisions"
+    archive_dir.mkdir(exist_ok=True)
+
+    if not revised.exists():
+        print("❌ No revised file found. Cannot accept.")
+        return
+
+    # Archive original if exists
+    if original.exists():
+        archived = archive_dir / f"chunk_{index+1:05d}_orig.wav"
+        shutil.move(str(original), str(archived))
+        print(f"📦 Original chunk archived to {archived.name}")
+    else:
+        print(f"⚠️ Original chunk missing — no archive created.")
+
+    # Move revised chunk to main filename
+    shutil.move(str(revised), str(original))
+    print(f"✅ Revised chunk accepted as {original.name}")

wrapper/chunk_revisions.py~

@@ -0,0 +1,33 @@
+import os
+import shutil
+from pathlib import Path
+from config.config import AUDIOBOOK_ROOT
+base = AUDIOBOOK_ROOT
+
+
+def accept_revision(index):
+    """
+    Archive original chunk and replace with revised version.
+    Assumes revised version is saved as: chunk_XXX_rev.wav
+    """
+    base = Path(AUDIO_OUTPUT_DIR)
+    original = base / f"chunk_{index:03}.wav"
+    revised = base / f"chunk_{index:03}_rev.wav"
+    archive_dir = base / "Audio_Revisions"
+    archive_dir.mkdir(exist_ok=True)
+
+    if not revised.exists():
+        print("❌ No revised file found. Cannot accept.")
+        return
+
+    # Archive original if exists
+    if original.exists():
+        archived = archive_dir / f"chunk_{index:03}_orig.wav"
+        shutil.move(original, archived)
+        print(f"📦 Original chunk archived to {archived.name}")
+    else:
+        print(f"⚠️ Original chunk missing — no archive created.")
+
+    # Move revised chunk to main filename
+    shutil.move(revised, original)
+    print(f"✅ Revised chunk accepted as {original.name}")

wrapper/chunk_search.py

@@ -0,0 +1,9 @@
+def search_chunks(chunks, query):
+    results = []
+    query_lower = query.lower()
+
+    for chunk in chunks:
+        if query_lower in chunk['text'].lower():
+            results.append(chunk)
+
+    return results

wrapper/chunk_search.py.bak

@@ -0,0 +1,9 @@
+def search_chunks(chunks, query):
+    results = []
+    query_lower = query.lower()
+
+    for chunk in chunks:
+        if query_lower in chunk['text'].lower():
+            results.append(chunk)
+
+    return results

wrapper/chunk_synthesizer.py

@@ -0,0 +1,208 @@
+from pathlib import Path
+import torch
+import time
+import re
+from pydub import AudioSegment
+
+from modules.tts_engine import load_optimized_model
+from modules.file_manager import ensure_voice_sample_compatibility, list_voice_samples
+from modules.audio_processor import apply_smart_fade_memory, smart_audio_validation_memory, process_audio_with_trimming_and_silence
+from config.config import *
+
+def get_original_voice_from_log(book_name):
+    """Extract original voice name from run log"""
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    log_file = audiobook_root / book_name / "run.log"
+    
+    if log_file.exists():
+        try:
+            with open(log_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith("Voice: ") or line.startswith("Voice used: "):
+                        voice_name = line.split(": ", 1)[1].strip()
+                        print(f"📄 Found original voice in log: {voice_name}")
+                        return voice_name
+        except Exception as e:
+            print(f"⚠️ Error reading run log: {e}")
+    
+    return None
+
+def get_original_voice_from_filename(book_name):
+    """Extract voice name from existing audiobook filename"""
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    book_dir = audiobook_root / book_name
+    
+    # Look for WAV files with voice pattern: BookName [VoiceName].wav
+    for wav_file in book_dir.glob("*.wav"):
+        match = re.search(r'\[([^\]]+)\]\.wav$', wav_file.name)
+        if match:
+            voice_name = match.group(1)
+            print(f"📁 Found original voice in filename: {voice_name}")
+            return voice_name
+    
+    # Look for M4B files with voice pattern: BookName[VoiceName].m4b
+    for m4b_file in book_dir.glob("*.m4b"):
+        match = re.search(r'\[([^\]]+)\]\.m4b$', m4b_file.name)
+        if match:
+            voice_name = match.group(1)
+            print(f"📁 Found original voice in M4B filename: {voice_name}")
+            return voice_name
+    
+    return None
+
+def find_voice_file_by_name(voice_name):
+    """Find voice file by name in Voice_Samples directory"""
+    voice_files = list_voice_samples()
+    
+    # Exact match first
+    for voice_file in voice_files:
+        if voice_file.stem == voice_name:
+            print(f"✅ Found exact voice match: {voice_file.name}")
+            return voice_file
+    
+    # Partial match (case insensitive)
+    voice_name_lower = voice_name.lower()
+    for voice_file in voice_files:
+        if voice_name_lower in voice_file.stem.lower():
+            print(f"✅ Found partial voice match: {voice_file.name}")
+            return voice_file
+    
+    return None
+
+def get_tts_params_for_chunk(chunk):
+    """Extract TTS parameters from chunk data or prompt user"""
+    # Check if chunk has TTS params stored
+    if 'tts_params' in chunk:
+        tts_params = chunk['tts_params']
+        print(f"📊 Using stored TTS params: exag={tts_params.get('exaggeration', 1.0)}, cfg={tts_params.get('cfg_weight', 0.7)}, temp={tts_params.get('temperature', 0.7)}")
+        return tts_params
+    
+    # Prompt user for TTS parameters
+    print(f"\n⚙️ TTS Parameters for chunk synthesis:")
+    
+    def get_float_input(prompt, default):
+        while True:
+            try:
+                value = input(f"{prompt} [{default}]: ").strip()
+                if not value:
+                    return default
+                return float(value)
+            except ValueError:
+                print(f"❌ Invalid input. Please enter a valid number.")
+    
+    exaggeration = get_float_input("Exaggeration", DEFAULT_EXAGGERATION)
+    cfg_weight = get_float_input("CFG Weight", DEFAULT_CFG_WEIGHT)
+    temperature = get_float_input("Temperature", DEFAULT_TEMPERATURE)
+    
+    return {
+        'exaggeration': exaggeration,
+        'cfg_weight': cfg_weight,
+        'temperature': temperature
+    }
+
+def synthesize_chunk(chunk, index, book_name, audio_dir, revision=False, chunks_json_path=None, override_voice_name=None):
+    """Generate audio for a single chunk using specified or detected voice and TTS parameters"""
+    filename = f"chunk_{index+1:05d}_rev.wav" if revision else f"chunk_{index+1:05d}.wav"
+    out_path = Path(audio_dir) / filename
+    
+    try:
+        # Get device
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        # Load TTS model
+        print(f"🤖 Loading TTS model for chunk synthesis...")
+        model = load_optimized_model(device)
+        
+        # Determine voice to use
+        if override_voice_name:
+            # Use explicitly provided voice
+            print(f"🎤 Using explicitly selected voice: {override_voice_name}")
+            voice_path = find_voice_file_by_name(override_voice_name)
+            voice_name = override_voice_name
+            detection_method = "user_selected"
+        else:
+            # Use enhanced voice detection
+            print(f"🔍 Detecting original voice for book: {book_name}")
+            from modules.voice_detector import detect_voice_for_book
+            
+            voice_name, voice_path, detection_method = detect_voice_for_book(book_name, chunks_json_path)
+        
+        # Fallback to first available voice if detection failed
+        if not voice_path:
+            print(f"⚠️ Voice not found, using first available voice")
+            voice_files = list_voice_samples()
+            if not voice_files:
+                print("❌ No voice samples found")
+                return None
+            voice_path = voice_files[0]
+            voice_name = voice_path.stem
+            detection_method = "fallback_first_available"
+        
+        print(f"🎤 Using voice: {voice_name} (method: {detection_method})")
+        compatible_voice = ensure_voice_sample_compatibility(voice_path)
+        
+        # Get TTS parameters for this chunk
+        tts_params = get_tts_params_for_chunk(chunk)
+        
+        # Prepare model with voice
+        model.prepare_conditionals(compatible_voice)
+        
+        # Get chunk text
+        chunk_text = chunk.get('text', '')
+        if not chunk_text:
+            print("❌ No text found in chunk")
+            return None
+            
+        print(f"🎤 Synthesizing: {chunk_text[:50]}...")
+        print(f"📊 TTS params: exag={tts_params['exaggeration']}, cfg={tts_params['cfg_weight']}, temp={tts_params['temperature']}")
+        
+        # Generate audio with specified parameters
+        with torch.no_grad():
+            wav = model.generate(chunk_text, 
+                               exaggeration=tts_params['exaggeration'],
+                               cfg_weight=tts_params['cfg_weight'], 
+                               temperature=tts_params['temperature']).detach().cpu()
+        
+        if wav.dim() == 1:
+            wav = wav.unsqueeze(0)
+            
+        # Convert tensor to AudioSegment for processing
+        import io
+        import soundfile as sf
+        
+        wav_np = wav.squeeze().numpy()
+        with io.BytesIO() as wav_buffer:
+            sf.write(wav_buffer, wav_np, model.sr, format='wav')
+            wav_buffer.seek(0)
+            audio_segment = AudioSegment.from_wav(wav_buffer)
+        
+        # Apply audio processing
+        audio_segment = apply_smart_fade_memory(audio_segment)
+        audio_segment, is_quarantined = smart_audio_validation_memory(audio_segment, model.sr)
+        
+        # Apply trimming and contextual silence based on boundary type
+        boundary_type = chunk.get('boundary_type', 'none')
+        if boundary_type and boundary_type != "none":
+            audio_segment = process_audio_with_trimming_and_silence(audio_segment, boundary_type)
+        else:
+            # Apply trimming even without boundary type if enabled
+            if ENABLE_AUDIO_TRIMMING:
+                from modules.audio_processor import trim_audio_endpoint
+                audio_segment = trim_audio_endpoint(audio_segment)
+            
+        # Save final audio
+        audio_segment.export(out_path, format="wav")
+        print(f"✅ Saved synthesized chunk: {out_path.name}")
+        
+        # Clean up model
+        del model
+        torch.cuda.empty_cache()
+        
+        return str(out_path)
+        
+    except Exception as e:
+        print(f"❌ Failed to synthesize chunk: {e}")
+        import traceback
+        traceback.print_exc()
+        return None

wrapper/chunk_synthesizer.py.bak

@@ -0,0 +1,90 @@
+from pathlib import Path
+import torch
+import time
+from pydub import AudioSegment
+
+from modules.tts_engine import load_optimized_model
+from modules.file_manager import ensure_voice_sample_compatibility, list_voice_samples
+from modules.audio_processor import apply_smart_fade_memory, smart_audio_validation_memory, add_contextual_silence_memory
+from config.config import *
+
+def synthesize_chunk(chunk, index, book_name, audio_dir, revision=False):
+    """Generate audio for a single chunk using simplified TTS process"""
+    filename = f"chunk_{index+1:05d}_rev.wav" if revision else f"chunk_{index+1:05d}.wav"
+    out_path = Path(audio_dir) / filename
+    
+    try:
+        # Get device
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        # Load TTS model
+        print(f"🤖 Loading TTS model for chunk synthesis...")
+        model = load_optimized_model(device)
+        
+        # Get voice sample - use first available voice for now
+        voice_files = list_voice_samples()
+        if not voice_files:
+            print("❌ No voice samples found")
+            return None
+            
+        voice_path = voice_files[0]  # Use first available voice
+        compatible_voice = ensure_voice_sample_compatibility(voice_path)
+        
+        # Prepare model with voice
+        model.prepare_conditionals(compatible_voice, exaggeration=1.0)
+        
+        # Get chunk text
+        chunk_text = chunk.get('text', '')
+        if not chunk_text:
+            print("❌ No text found in chunk")
+            return None
+            
+        print(f"🎤 Synthesizing: {chunk_text[:50]}...")
+        
+        # Generate audio
+        with torch.no_grad():
+            wav = model.generate(chunk_text, 
+                               exaggeration=1.0,
+                               cfg_weight=0.7, 
+                               temperature=0.7).detach().cpu()
+        
+        if wav.dim() == 1:
+            wav = wav.unsqueeze(0)
+            
+        # Convert tensor to AudioSegment for processing
+        import io
+        import soundfile as sf
+        
+        wav_np = wav.squeeze().numpy()
+        with io.BytesIO() as wav_buffer:
+            sf.write(wav_buffer, wav_np, model.sr, format='wav')
+            wav_buffer.seek(0)
+            audio_segment = AudioSegment.from_wav(wav_buffer)
+        
+        # Apply audio processing
+        audio_segment = apply_smart_fade_memory(audio_segment)
+        audio_segment, is_quarantined = smart_audio_validation_memory(audio_segment, model.sr)
+        
+        # Add contextual silence if specified
+        boundary_type = chunk.get('boundary_type', 'none')
+        if boundary_type and boundary_type != "none":
+            audio_segment = add_contextual_silence_memory(audio_segment, boundary_type)
+        elif chunk.get('is_paragraph_end', False):
+            silence = AudioSegment.silent(duration=SILENCE_PARAGRAPH_FALLBACK)
+            audio_segment = audio_segment + silence
+            
+        # Save final audio
+        audio_segment.export(out_path, format="wav")
+        print(f"✅ Saved synthesized chunk: {out_path.name}")
+        
+        # Clean up model
+        del model
+        torch.cuda.empty_cache()
+        
+        return str(out_path)
+        
+    except Exception as e:
+        print(f"❌ Failed to synthesize chunk: {e}")
+        import traceback
+        traceback.print_exc()
+        return None

wrapper/chunk_synthesizer.py~

@@ -0,0 +1,15 @@
+from modules.tts_engine import process_one_chunk
+from config.config import AUDIOBOOK_ROOT
+
+
+def synthesize_chunk(chunk, index, revision=False):
+    """Generate audio for a single chunk"""
+    filename = f"chunk_{index:03}_rev.wav" if revision else f"chunk_{index:03}.wav"
+    out_path = AUDIO_OUTPUT_DIR / filename
+
+    try:
+        process_one_chunk(chunk, out_path)  # Must accept (chunk_dict, output_path)
+        return str(out_path)
+    except Exception as e:
+        print(f"❌ Failed to synthesize chunk: {e}")
+        return None

wrapper/chunk_tool.py

@@ -0,0 +1,249 @@
+from wrapper.chunk_loader import load_chunks, save_chunks
+from wrapper.chunk_search import search_chunks
+from wrapper.chunk_editor import update_chunk
+from wrapper.chunk_player import play_chunk_audio
+from wrapper.chunk_synthesizer import synthesize_chunk
+from wrapper.chunk_revisions import accept_revision
+import os
+from config.config import AUDIOBOOK_ROOT
+AUDIO_DIR = AUDIOBOOK_ROOT
+
+def select_book_for_repair():
+    """Let user select which book to repair"""
+    from pathlib import Path
+    
+    # Look for books in both locations: TTS processing dirs and Text_Input
+    available_books = []
+    
+    # First check TTS processing directories
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    if audiobook_root.exists():
+        for book_dir in audiobook_root.iterdir():
+            if book_dir.is_dir():
+                tts_chunks_dir = book_dir / "TTS" / "text_chunks"
+                json_path = tts_chunks_dir / "chunks_info.json"
+                if json_path.exists():
+                    available_books.append((book_dir.name, json_path, "TTS"))
+    
+    # Then check Text_Input directory for fallback
+    text_input_dir = Path("Text_Input")
+    if text_input_dir.exists():
+        for chunk_file in text_input_dir.glob("*_chunks.json"):
+            book_name = chunk_file.stem.replace("_chunks", "")
+            # Only add if not already found in TTS directories
+            if not any(book[0] == book_name for book in available_books):
+                available_books.append((book_name, chunk_file, "Text_Input"))
+    
+    if not available_books:
+        print("❌ No chunk files found in TTS processing directories or Text_Input/")
+        return None, None
+    
+    print("\n📚 Available books for repair:")
+    for i, (book_name, json_path, source) in enumerate(available_books):
+        print(f"  [{i}] {book_name} ({source}: {json_path.name})")
+    
+    while True:
+        try:
+            choice = input(f"\nSelect book index [0-{len(available_books)-1}]: ").strip()
+            idx = int(choice)
+            if 0 <= idx < len(available_books):
+                book_name, json_path, source = available_books[idx]
+                return book_name, json_path
+            else:
+                print(f"❌ Please enter a number between 0 and {len(available_books)-1}")
+        except (ValueError, EOFError, KeyboardInterrupt):
+            print("❌ Invalid selection or cancelled")
+            return None, None
+
+def run_chunk_repair_tool():
+    print("\n🛠️ Chunk Repair & Revision Tool")
+    
+    # Ask user to select book
+    book_name, chunk_path = select_book_for_repair()
+    if not chunk_path:
+        return
+    
+    print(f"\n📖 Loading chunks from: {chunk_path.name}")
+    chunks = load_chunks(str(chunk_path))
+    
+    # Determine audio directory path based on book structure
+    from pathlib import Path
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    book_audio_dir = audiobook_root / book_name / "TTS" / "audio_chunks"
+    
+    if not book_audio_dir.exists():
+        print(f"❌ Audio directory not found: {book_audio_dir}")
+        print(f"📁 Looked for: {book_audio_dir}")
+        return
+    
+    print(f"📁 Using audio directory: {book_audio_dir}")
+
+    while True:
+        query = input("\nSearch for text fragment (or 'Q' to quit): ").strip()
+        if query.lower() == "q":
+            print("Exiting revision tool.")
+            break
+
+        results = search_chunks(chunks, query)
+        if not results:
+            print("❌ No matching chunks found.")
+            continue
+
+        print(f"\n🔍 Found {len(results)} match(es):")
+        for i, chunk in enumerate(results):
+            print(f"[{i}] \"{chunk['text'][:60]}...\" | Index: {chunk['index']}")
+
+        sel = input("Select chunk index to revise: ").strip()
+        if not sel.isdigit() or int(sel) >= len(results):
+            print("Invalid selection.")
+            continue
+
+        chunk = results[int(sel)]
+        index = chunk['index']
+        # Use 5-digit chunk numbering and correct directory path
+        chunk_audio_path = book_audio_dir / f"chunk_{index+1:05d}.wav"
+        chunk_audio_path_str = str(chunk_audio_path)
+
+        while True:
+            print(f"\n📝 Chunk: \"{chunk['text']}\"")
+            
+            # Display current chunk metadata
+            sentiment_compound = chunk.get('sentiment_compound', chunk.get('sentiment_score', 'N/A'))
+            tts_params = chunk.get('tts_params', {})
+            
+            print(f"  📍 Index: {index}, Boundary: {chunk['boundary_type']}")
+            print(f"  😊 Sentiment: {sentiment_compound}")
+            print(f"  🎛️  TTS Params: exag={tts_params.get('exaggeration', 'N/A')}, cfg={tts_params.get('cfg_weight', 'N/A')}, temp={tts_params.get('temperature', 'N/A')}")
+            print(f"  📁 Audio file: chunk_{index+1:05d}.wav")
+            print("\nOptions:")
+            print(" 1. Play original audio")
+            print(" 2. Edit text content")
+            print(" 3. Edit chunk metadata (boundary, sentiment)")
+            print(" 4. Edit TTS parameters (exaggeration, cfg_weight, temperature)")
+            print(" 5. Resynthesize audio with current settings")
+            print(" 6. Play revised audio")
+            print(" 7. Accept revision (replace original with revised)")
+            print(" 8. Back to search")
+
+            try:
+                choice = input("\n💡 Enter option number [1-8]: ").strip()
+            except (EOFError, KeyboardInterrupt):
+                print("\n❌ Input cancelled")
+                return
+            if choice == "1":
+                print(f"\n🔊 Playing original audio: {chunk_audio_path.name}")
+                play_chunk_audio(chunk_audio_path_str)
+            elif choice == "2":
+                print("\n✏️ Edit Text Content:")
+                print(f"Current text: \"{chunk['text']}\"")
+                print("💡 Enter new text (or Enter to cancel):")
+                new_text = input(">>> ").strip()
+                
+                if new_text:
+                    chunk['text'] = new_text
+                    chunk['word_count'] = len(new_text.split())
+                    save_chunks(str(chunk_path), chunks)
+                    print("✅ Text content updated successfully")
+                    print(f"📊 New word count: {chunk['word_count']}")
+                else:
+                    print("❌ No changes made")
+            elif choice == "3":
+                print("\n✏️ Edit Chunk Metadata:")
+                print(f"Current boundary type: {chunk['boundary_type']}")
+                boundary = input("New boundary type (none/paragraph_end/chapter_start/chapter_end/section_break) [Enter to skip]: ").strip()
+                
+                current_sentiment = chunk.get('sentiment_compound', chunk.get('sentiment_score', 'N/A'))
+                print(f"Current sentiment score: {current_sentiment}")
+                sentiment = input("New sentiment compound score (-1.0 to 1.0) [Enter to skip]: ").strip()
+
+                try:
+                    if boundary:
+                        chunk['boundary_type'] = boundary
+                        print(f"✅ Updated boundary type to: {boundary}")
+                    
+                    if sentiment:
+                        sentiment_val = float(sentiment)
+                        if -1.0 <= sentiment_val <= 1.0:
+                            chunk['sentiment_compound'] = sentiment_val
+                            # Also update old key for compatibility
+                            chunk['sentiment_score'] = sentiment_val
+                            print(f"✅ Updated sentiment score to: {sentiment_val}")
+                        else:
+                            print("❌ Sentiment score must be between -1.0 and 1.0")
+                    
+                    save_chunks(str(chunk_path), chunks)
+                    print("✅ Chunk metadata updated successfully")
+                except ValueError as e:
+                    print(f"❌ Invalid input: {e}")
+                except Exception as e:
+                    print(f"❌ Error updating chunk: {e}")
+            elif choice == "4":
+                print("\n🎛️ Edit TTS Parameters:")
+                current_tts_params = chunk.get('tts_params', {})
+                
+                def get_float_input(param_name, current_val, min_val=None, max_val=None):
+                    while True:
+                        try:
+                            prompt = f"New {param_name} [{current_val}]: "
+                            value = input(prompt).strip()
+                            if not value:
+                                return current_val
+                            new_val = float(value)
+                            if min_val is not None and new_val < min_val:
+                                print(f"❌ {param_name} must be >= {min_val}")
+                                continue
+                            if max_val is not None and new_val > max_val:
+                                print(f"❌ {param_name} must be <= {max_val}")
+                                continue
+                            return new_val
+                        except ValueError:
+                            print(f"❌ Invalid input. Please enter a valid number.")
+                
+                # Edit TTS parameters
+                print(f"Current TTS parameters:")
+                current_exag = current_tts_params.get('exaggeration', 1.0)
+                current_cfg = current_tts_params.get('cfg_weight', 0.7)
+                current_temp = current_tts_params.get('temperature', 0.7)
+                
+                print(f"  Exaggeration: {current_exag}")
+                print(f"  CFG Weight: {current_cfg}")
+                print(f"  Temperature: {current_temp}")
+                
+                new_exag = get_float_input("exaggeration", current_exag, 0.0, 3.0)
+                new_cfg = get_float_input("CFG weight", current_cfg, 0.0, 2.0)
+                new_temp = get_float_input("temperature", current_temp, 0.0, 2.0)
+                
+                # Update chunk TTS parameters
+                if 'tts_params' not in chunk:
+                    chunk['tts_params'] = {}
+                
+                chunk['tts_params']['exaggeration'] = new_exag
+                chunk['tts_params']['cfg_weight'] = new_cfg
+                chunk['tts_params']['temperature'] = new_temp
+                
+                save_chunks(str(chunk_path), chunks)
+                print(f"✅ TTS parameters updated: exag={new_exag}, cfg={new_cfg}, temp={new_temp}")
+            elif choice == "5":
+                print(f"\n🎤 Resynthesizing chunk {index+1:05d}...")
+                revised_path = synthesize_chunk(chunk, index, book_name, book_audio_dir, revision=True)
+                if revised_path:
+                    print(f"✅ Chunk resynthesized: {revised_path}")
+                else:
+                    print("❌ Failed to resynthesize chunk")
+            elif choice == "6":
+                rev_path = book_audio_dir / f"chunk_{index+1:05d}_rev.wav"
+                print(f"\n🔊 Playing revised audio: {rev_path.name}")
+                play_chunk_audio(str(rev_path))
+            elif choice == "7":
+                print(f"\n📦 Accepting revision for chunk {index+1:05d}...")
+                accept_revision(index, book_audio_dir)
+                print("✅ Revision accepted successfully")
+                break
+            elif choice == "8":
+                print("🔙 Returning to search...")
+                break
+            elif choice.lower() == 'q':
+                print("🚪 Exiting chunk repair tool...")
+                return
+            else:
+                print(f"❌ Invalid option '{choice}'. Please enter a number 1-8 (or 'q' to quit).")

wrapper/chunk_tool.py.bak

@@ -0,0 +1,191 @@
+from wrapper.chunk_loader import load_chunks, save_chunks
+from wrapper.chunk_search import search_chunks
+from wrapper.chunk_editor import update_chunk
+from wrapper.chunk_player import play_chunk_audio
+from wrapper.chunk_synthesizer import synthesize_chunk
+from wrapper.chunk_revisions import accept_revision
+import os
+from config.config import AUDIOBOOK_ROOT
+AUDIO_DIR = AUDIOBOOK_ROOT
+
+def select_book_for_repair():
+    """Let user select which book to repair"""
+    from pathlib import Path
+    
+    # Look for books in both locations: TTS processing dirs and Text_Input
+    available_books = []
+    
+    # First check TTS processing directories
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    if audiobook_root.exists():
+        for book_dir in audiobook_root.iterdir():
+            if book_dir.is_dir():
+                tts_chunks_dir = book_dir / "TTS" / "text_chunks"
+                json_path = tts_chunks_dir / "chunks_info.json"
+                if json_path.exists():
+                    available_books.append((book_dir.name, json_path, "TTS"))
+    
+    # Then check Text_Input directory for fallback
+    text_input_dir = Path("Text_Input")
+    if text_input_dir.exists():
+        for chunk_file in text_input_dir.glob("*_chunks.json"):
+            book_name = chunk_file.stem.replace("_chunks", "")
+            # Only add if not already found in TTS directories
+            if not any(book[0] == book_name for book in available_books):
+                available_books.append((book_name, chunk_file, "Text_Input"))
+    
+    if not available_books:
+        print("❌ No chunk files found in TTS processing directories or Text_Input/")
+        return None, None
+    
+    print("\n📚 Available books for repair:")
+    for i, (book_name, json_path, source) in enumerate(available_books):
+        print(f"  [{i}] {book_name} ({source}: {json_path.name})")
+    
+    while True:
+        try:
+            choice = input(f"\nSelect book index [0-{len(available_books)-1}]: ").strip()
+            idx = int(choice)
+            if 0 <= idx < len(available_books):
+                book_name, json_path, source = available_books[idx]
+                return book_name, json_path
+            else:
+                print(f"❌ Please enter a number between 0 and {len(available_books)-1}")
+        except (ValueError, EOFError, KeyboardInterrupt):
+            print("❌ Invalid selection or cancelled")
+            return None, None
+
+def run_chunk_repair_tool():
+    print("\n🛠️ Chunk Repair & Revision Tool")
+    
+    # Ask user to select book
+    book_name, chunk_path = select_book_for_repair()
+    if not chunk_path:
+        return
+    
+    print(f"\n📖 Loading chunks from: {chunk_path.name}")
+    chunks = load_chunks(str(chunk_path))
+    
+    # Determine audio directory path based on book structure
+    from pathlib import Path
+    audiobook_root = Path(AUDIOBOOK_ROOT)
+    book_audio_dir = audiobook_root / book_name / "TTS" / "audio_chunks"
+    
+    if not book_audio_dir.exists():
+        print(f"❌ Audio directory not found: {book_audio_dir}")
+        print(f"📁 Looked for: {book_audio_dir}")
+        return
+    
+    print(f"📁 Using audio directory: {book_audio_dir}")
+
+    while True:
+        query = input("\nSearch for text fragment (or 'Q' to quit): ").strip()
+        if query.lower() == "q":
+            print("Exiting revision tool.")
+            break
+
+        results = search_chunks(chunks, query)
+        if not results:
+            print("❌ No matching chunks found.")
+            continue
+
+        print(f"\n🔍 Found {len(results)} match(es):")
+        for i, chunk in enumerate(results):
+            print(f"[{i}] \"{chunk['text'][:60]}...\" | Index: {chunk['index']}")
+
+        sel = input("Select chunk index to revise: ").strip()
+        if not sel.isdigit() or int(sel) >= len(results):
+            print("Invalid selection.")
+            continue
+
+        chunk = results[int(sel)]
+        index = chunk['index']
+        # Use 5-digit chunk numbering and correct directory path
+        chunk_audio_path = book_audio_dir / f"chunk_{index+1:05d}.wav"
+        chunk_audio_path_str = str(chunk_audio_path)
+
+        while True:
+            print(f"\n📝 Chunk: \"{chunk['text']}\"")
+            print(f"  Boundary: {chunk['boundary_type']}, Sentiment: {chunk.get('sentiment_score', 'N/A')}, Pause: {chunk.get('pause_duration', 'N/A')}")
+            print(f"  Audio file: chunk_{index+1:05d}.wav")
+            print("\nOptions:")
+            print(" 1. Play original audio")
+            print(" 2. Edit text content")
+            print(" 3. Edit chunk values (boundary, sentiment, pause)")
+            print(" 4. Resynthesize audio with current settings")
+            print(" 5. Play revised audio")
+            print(" 6. Accept revision (replace original with revised)")
+            print(" 7. Back to search")
+
+            try:
+                choice = input("\n💡 Enter option number [1-7]: ").strip()
+            except (EOFError, KeyboardInterrupt):
+                print("\n❌ Input cancelled")
+                return
+            if choice == "1":
+                print(f"\n🔊 Playing original audio: {chunk_audio_path.name}")
+                play_chunk_audio(chunk_audio_path_str)
+            elif choice == "2":
+                print("\n✏️ Edit Text Content:")
+                print(f"Current text: \"{chunk['text']}\"")
+                print("💡 Enter new text (or Enter to cancel):")
+                new_text = input(">>> ").strip()
+                
+                if new_text:
+                    chunk['text'] = new_text
+                    chunk['word_count'] = len(new_text.split())
+                    save_chunks(str(chunk_path), chunks)
+                    print("✅ Text content updated successfully")
+                    print(f"📊 New word count: {chunk['word_count']}")
+                else:
+                    print("❌ No changes made")
+            elif choice == "3":
+                print("\n✏️ Edit Chunk Values:")
+                print(f"Current boundary type: {chunk['boundary_type']}")
+                boundary = input("New boundary type (none/paragraph_end/chapter_start/chapter_end/section_break) [Enter to skip]: ").strip()
+                
+                current_sentiment = chunk.get('sentiment_score', 'N/A')
+                print(f"Current sentiment score: {current_sentiment}")
+                sentiment = input("New sentiment score (-1.0 to 1.0) [Enter to skip]: ").strip()
+                
+                current_pause = chunk.get('pause_duration', 'N/A')
+                print(f"Current pause duration: {current_pause}")
+                pause = input("New pause duration (milliseconds) [Enter to skip]: ").strip()
+
+                try:
+                    update_chunk(
+                        chunk,
+                        boundary_type=boundary if boundary else None,
+                        sentiment_score=float(sentiment) if sentiment else None,
+                        pause_duration=float(pause) if pause else None
+                    )
+                    save_chunks(str(chunk_path), chunks)
+                    print("✅ Chunk values updated successfully")
+                except ValueError as e:
+                    print(f"❌ Invalid input: {e}")
+                except Exception as e:
+                    print(f"❌ Error updating chunk: {e}")
+            elif choice == "4":
+                print(f"\n🎤 Resynthesizing chunk {index+1:05d}...")
+                revised_path = synthesize_chunk(chunk, index, book_name, book_audio_dir, revision=True)
+                if revised_path:
+                    print(f"✅ Chunk resynthesized: {revised_path}")
+                else:
+                    print("❌ Failed to resynthesize chunk")
+            elif choice == "5":
+                rev_path = book_audio_dir / f"chunk_{index+1:05d}_rev.wav"
+                print(f"\n🔊 Playing revised audio: {rev_path.name}")
+                play_chunk_audio(str(rev_path))
+            elif choice == "6":
+                print(f"\n📦 Accepting revision for chunk {index+1:05d}...")
+                accept_revision(index, book_audio_dir)
+                print("✅ Revision accepted successfully")
+                break
+            elif choice == "7":
+                print("🔙 Returning to search...")
+                break
+            elif choice.lower() == 'q':
+                print("🚪 Exiting chunk repair tool...")
+                return
+            else:
+                print(f"❌ Invalid option '{choice}'. Please enter a number 1-7 (or 'q' to quit).")

wrapper/chunk_tool.py~

@@ -0,0 +1,79 @@
+from wrapper.chunk_loader import load_chunks, save_chunks
+from wrapper.chunk_search import search_chunks
+from wrapper.chunk_editor import update_chunk
+from wrapper.chunk_player import play_chunk_audio
+from wrapper.chunk_synthesizer import synthesize_chunk
+from wrapper.chunk_revisions import accept_revision
+import os
+from config.config import AUDIOBOOK_ROOT
+AUDIO_DIR = AUDIOBOOK_ROO
+
+CHUNK_PATH = "Text_Input/my_book_chunks.json"
+
+
+def run_chunk_repair_tool():
+    print("\n🛠️ Chunk Repair & Revision Tool")
+    chunks = load_chunks(CHUNK_PATH)
+
+    while True:
+        query = input("\nSearch for text fragment (or 'Q' to quit): ").strip()
+        if query.lower() == "q":
+            print("Exiting revision tool.")
+            break
+
+        results = search_chunks(chunks, query)
+        if not results:
+            print("❌ No matching chunks found.")
+            continue
+
+        print(f"\n🔍 Found {len(results)} match(es):")
+        for i, chunk in enumerate(results):
+            print(f"[{i}] \"{chunk['text'][:60]}...\" | Index: {chunk['index']}")
+
+        sel = input("Select chunk index to revise: ").strip()
+        if not sel.isdigit() or int(sel) >= len(results):
+            print("Invalid selection.")
+            continue
+
+        chunk = results[int(sel)]
+        index = chunk['index']
+        chunk_path = os.path.join(AUDIO_DIR, f"chunk_{index:03}.wav")
+
+        while True:
+            print(f"\n📝 Chunk: \"{chunk['text']}\"")
+            print(f"  Boundary: {chunk['boundary_type']}, Sentiment: {chunk.get('sentiment_score', 'N/A')}, Pause: {chunk.get('pause_duration', 'N/A')}")
+            print("\nOptions:")
+            print(" 1. Play original")
+            print(" 2. Edit values")
+            print(" 3. Resynthesize")
+            print(" 4. Play revised")
+            print(" 5. Accept revision")
+            print(" 6. Back to search")
+
+            choice = input("Enter option number: ").strip()
+            if choice == "1":
+                play_chunk_audio(chunk_path)
+            elif choice == "2":
+                boundary = input("New boundary type (or Enter to skip): ").strip()
+                sentiment = input("New sentiment score (or Enter to skip): ").strip()
+                pause = input("New pause duration (or Enter to skip): ").strip()
+
+                update_chunk(
+                    chunk,
+                    boundary_type=boundary if boundary else None,
+                    sentiment_score=float(sentiment) if sentiment else None,
+                    pause_duration=float(pause) if pause else None
+                )
+                save_chunks(CHUNK_PATH, chunks)
+            elif choice == "3":
+                synthesize_chunk(chunk, index, revision=True)
+            elif choice == "4":
+                rev_path = os.path.join(AUDIO_DIR, f"chunk_{index:03}_rev.wav")
+                play_chunk_audio(rev_path)
+            elif choice == "5":
+                accept_revision(index)
+                break
+            elif choice == "6":
+                break
+            else:
+                print("Invalid input. Try again.")