Update app.py

app.py

@@ -1,5 +1,3 @@
-print("starting...")
-
 import os
 import shutil
 import subprocess
@@ -13,411 +11,769 @@ import ebooklib
 import bs4
 from ebooklib import epub
 from bs4 import BeautifulSoup
-from gradio import Progress
-import sys
 from nltk.tokenize import sent_tokenize
 import csv
-nltk.download('punkt_tab')
-
-# Ensure necessary models are downloaded
-# nltk.download('punkt')
-
-def is_folder_empty(folder_path):
-    if os.path.exists(folder_path) and os.path.isdir(folder_path):
-        return not os.listdir(folder_path)
-    else:
-        print(f"The path {folder_path} is not a valid folder.")
-        return None
-
-def remove_folder_with_contents(folder_path):
-    try:
-        shutil.rmtree(folder_path)
-        print(f"Successfully removed {folder_path} and all of its contents.")
-    except Exception as e:
-        print(f"Error removing {folder_path}: {e}")
+import argparse
+import threading
+import logging
+from datetime import datetime
+import time
+import json
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("audiobook_converter.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("audiobook_converter")
+
+# Download NLTK resources if not already present
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    logger.info("Downloading NLTK punkt tokenizer...")
+    nltk.download('punkt', quiet=True)
+
+# Utility functions for directory management
+def ensure_directory(directory_path):
+    """Create directory if it doesn't exist."""
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+        logger.info(f"Created directory: {directory_path}")
+    return directory_path
+
+def remove_directory(folder_path):
+    """Remove directory and all its contents."""
+    if os.path.exists(folder_path):
+        try:
+            shutil.rmtree(folder_path)
+            logger.info(f"Removed directory: {folder_path}")
+        except Exception as e:
+            logger.error(f"Error removing directory {folder_path}: {e}")
 
-def wipe_folder(folder_path):
+def wipe_directory(folder_path):
+    """Remove all contents of a directory without deleting the directory itself."""
     if not os.path.exists(folder_path):
-        print(f"The folder {folder_path} does not exist.")
+        logger.warning(f"Directory does not exist: {folder_path}")
         return
+    
     for item in os.listdir(folder_path):
         item_path = os.path.join(folder_path, item)
-        if os.path.isfile(item_path):
-            os.remove(item_path)
-        elif os.path.isdir(item_path):
-            shutil.rmtree(item_path)
-    
-    print(f"All contents wiped from {folder_path}.")
-
-def create_m4b_from_chapters(input_dir, ebook_file, output_dir):
-    def sort_key(chapter_file):
-        numbers = re.findall(r'\d+', chapter_file)
-        return int(numbers[0]) if numbers else 0
-
-    def extract_metadata_and_cover(ebook_path):
         try:
-            cover_path = ebook_path.rsplit('.', 1)[0] + '.jpg'
-            subprocess.run(['ebook-meta', ebook_path, '--get-cover', cover_path], check=True)
-            if (os.path.exists(cover_path)):
-                return cover_path
+            if os.path.isfile(item_path):
+                os.remove(item_path)
+            elif os.path.isdir(item_path):
+                shutil.rmtree(item_path)
         except Exception as e:
-            print(f"Error extracting eBook metadata or cover: {e}")
+            logger.error(f"Error removing {item_path}: {e}")
+    
+    logger.info(f"Wiped contents of directory: {folder_path}")
+
+# Text processing functions
+def clean_text(text):
+    """Clean up text by removing unnecessary whitespace and fixing common issues."""
+    # Replace multiple newlines with a single one
+    text = re.sub(r'\n\s*\n', '\n\n', text)
+    # Replace multiple spaces with a single space
+    text = re.sub(r' +', ' ', text)
+    # Fix broken sentences (e.g., "word . Next" -> "word. Next")
+    text = re.sub(r'(\w) \. (\w)', r'\1. \2', text)
+    return text.strip()
+
+def split_into_natural_sentences(text):
+    """Split text into natural sentences using NLTK with additional rules."""
+    # Initial sentence splitting
+    sentences = sent_tokenize(text)
+    
+    # Post-process sentences to handle special cases
+    processed_sentences = []
+    buffer = ""
+    
+    for sent in sentences:
+        # Handle quotes that span multiple sentences but should be treated as one
+        if buffer:
+            current = buffer + " " + sent
+            buffer = ""
+        else:
+            current = sent
+            
+        # Check for unbalanced quotes, which might indicate a continuing sentence
+        if current.count('"') % 2 != 0 or current.count("'") % 2 != 0:
+            buffer = current
+            continue
+            
+        # Check if sentence ends with abbreviation or is too short (might be a continuation)
+        if len(current) < 20 and not re.search(r'[.!?]\s*$', current):
+            buffer = current
+            continue
+            
+        processed_sentences.append(current)
+    
+    # Add any remaining buffer
+    if buffer:
+        processed_sentences.append(buffer)
+        
+    return processed_sentences
+
+# eBook processing functions
+def extract_metadata_and_cover(ebook_path):
+    """Extract metadata and cover image from an ebook."""
+    cover_path = ebook_path.rsplit('.', 1)[0] + '.jpg'
+    
+    try:
+        subprocess.run(['ebook-meta', ebook_path, '--get-cover', cover_path], 
+                      check=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        
+        # Check if cover was extracted
+        if os.path.exists(cover_path) and os.path.getsize(cover_path) > 0:
+            logger.info(f"Cover extracted to: {cover_path}")
+            return cover_path
+        else:
+            logger.warning("Cover extraction failed or resulted in empty file")
+            return None
+    except Exception as e:
+        logger.error(f"Error extracting eBook metadata: {e}")
         return None
 
-    def combine_wav_files(chapter_files, output_path):
-        combined_audio = AudioSegment.empty()
+def convert_to_epub(input_path, output_path):
+    """Convert any ebook format to EPUB using Calibre."""
+    try:
+        logger.info(f"Converting {input_path} to EPUB format...")
+        result = subprocess.run(
+            ['ebook-convert', input_path, output_path, '--enable-heuristics'],
+            check=True, 
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE
+        )
+        logger.info(f"Successfully converted to EPUB: {output_path}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error converting to EPUB: {e}")
+        logger.error(f"STDERR: {e.stderr.decode('utf-8', errors='replace')}")
+        return False
 
-        for chapter_file in chapter_files:
-            audio_segment = AudioSegment.from_wav(chapter_file)
-            combined_audio += audio_segment
-        combined_audio.export(output_path, format='wav')
-        print(f"Combined audio saved to {output_path}")
+def convert_to_text(input_path, output_path):
+    """Convert any ebook format directly to TXT using Calibre."""
+    try:
+        logger.info(f"Converting {input_path} to TXT format...")
+        result = subprocess.run(
+            ['ebook-convert', input_path, output_path, 
+             '--enable-heuristics',
+             '--chapter-mark=pagebreak',
+             '--paragraph-type=unformatted'],
+            check=True,
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE
+        )
+        logger.info(f"Successfully converted to TXT: {output_path}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error converting to TXT: {e}")
+        logger.error(f"STDERR: {e.stderr.decode('utf-8', errors='replace')}")
+        return False
+
+def detect_chapters_from_text(text_path):
+    """Detect chapters in a text file based on common patterns."""
+    with open(text_path, 'r', encoding='utf-8', errors='replace') as f:
+        content = f.read()
+    
+    # Different chapter detection patterns
+    chapter_patterns = [
+        r'(?:^|\n)(?:\s*)(?:Chapter|CHAPTER)\s+[0-9IVXLCDM]+(?:\s*:|\.\s|\s)(.+?)(?=\n)',
+        r'(?:^|\n)(?:\s*)(?:Chapter|CHAPTER)\s+[0-9IVXLCDM]+(?:\s*:|\.\s|\s)',
+        r'(?:^|\n)(?:\s*)(?:[0-9]+|[IVXLCDM]+)\.?\s+(.+?)(?=\n)',
+        r'(?:^|\n)(?:\s*)\* \* \*(?:\s*\n)',
+        r'(?:^|\n)(?:\s*)[-—]\s*(\d+\s*[-—]|\w+)(?:\s*\n)'
+    ]
+    
+    chapters = []
+    
+    for pattern in chapter_patterns:
+        matches = re.finditer(pattern, content, re.MULTILINE)
+        positions = [(m.start(), m.group()) for m in matches]
+        if positions:
+            # If we found chapters with this pattern, add to our list
+            for i, (pos, title) in enumerate(positions):
+                end_pos = positions[i+1][0] if i < len(positions)-1 else len(content)
+                chapter_text = content[pos:end_pos].strip()
+                chapters.append((i+1, clean_text(chapter_text)))
+            
+            # If we found chapters with this pattern, stop looking
+            if len(chapters) > 3:  # Require at least 3 chapters for a valid detection
+                break
+    
+    # If no chapters detected, create artificial chapters based on length
+    if not chapters:
+        logger.info("No clear chapter markers found, creating artificial chapters")
+        chunk_size = min(10000, max(5000, len(content) // 20))  # Aim for ~20 chapters
+        
+        # Split content into chunks
+        chunks = [content[i:i+chunk_size] for i in range(0, len(content), chunk_size)]
+        chapters = [(i+1, clean_text(chunk)) for i, chunk in enumerate(chunks)]
+    
+    return chapters
+
+def save_chapters_as_files(chapters, output_dir):
+    """Save detected chapters as individual text files."""
+    ensure_directory(output_dir)
+    
+    for chapter_num, chapter_text in chapters:
+        filename = f"chapter_{chapter_num:03d}.txt"
+        filepath = os.path.join(output_dir, filename)
+        
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(chapter_text)
+        
+        logger.info(f"Saved chapter {chapter_num} to {filename}")
+    
+    return len(chapters)
 
-    def generate_ffmpeg_metadata(chapter_files, metadata_file):
-        with open(metadata_file, 'w') as file:
-            file.write(';FFMETADATA1\n')
-            start_time = 0
-            for index, chapter_file in enumerate(chapter_files):
-                duration_ms = len(AudioSegment.from_wav(chapter_file))
-                file.write(f'[CHAPTER]\nTIMEBASE=1/1000\nSTART={start_time}\n')
-                file.write(f'END={start_time + duration_ms}\ntitle=Chapter {index + 1}\n')
-                start_time += duration_ms
+def process_ebook_to_chapters(ebook_path, chapters_dir):
+    """Process ebook into chapter text files."""
+    ensure_directory(chapters_dir)
+    
+    # Create temp directory for intermediate files
+    temp_dir = os.path.join(os.path.dirname(chapters_dir), "temp")
+    ensure_directory(temp_dir)
+    
+    # Determine file paths
+    temp_epub = os.path.join(temp_dir, "converted.epub")
+    temp_txt = os.path.join(temp_dir, "converted.txt")
+    
+    # First try direct conversion to text
+    if convert_to_text(ebook_path, temp_txt):
+        chapters = detect_chapters_from_text(temp_txt)
+        num_chapters = save_chapters_as_files(chapters, chapters_dir)
+        logger.info(f"Processed {num_chapters} chapters from text conversion")
+        return num_chapters
+    
+    # If that fails, try EPUB conversion first
+    logger.info("Direct text conversion failed, trying via EPUB...")
+    if convert_to_epub(ebook_path, temp_epub) and convert_to_text(temp_epub, temp_txt):
+        chapters = detect_chapters_from_text(temp_txt)
+        num_chapters = save_chapters_as_files(chapters, chapters_dir)
+        logger.info(f"Processed {num_chapters} chapters via EPUB conversion")
+        return num_chapters
+    
+    # If both methods fail, return 0 chapters
+    logger.error("Failed to process ebook into chapters")
+    return 0
+
+# Audio processing functions
+def sanitize_for_espeak(text):
+    """Sanitize text for espeak compatibility."""
+    # Replace problematic characters
+    text = re.sub(r'[–—]', '-', text)  # Em/en dashes to hyphens
+    text = re.sub(r'["""]', '"', text)  # Smart quotes to regular quotes
+    text = re.sub(r'[''`]', "'", text)  # Smart apostrophes to regular apostrophes
+    text = re.sub(r'[…]', '...', text)  # Ellipsis character to three dots
+    
+    # Remove or replace other problematic characters
+    text = re.sub(r'[<>|]', ' ', text)
+    text = re.sub(r'[\x00-\x1F\x7F]', '', text)  # Control characters
+    
+    return text
 
-    def create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
-        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
+def convert_text_to_speech(text, output_path, voice="en", speed=170, pitch=50, gap=5):
+    """Convert text to speech using espeak-ng."""
+    try:
+        # Create a temporary file for the text
+        with tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8', suffix='.txt', delete=False) as temp_file:
+            temp_file.write(sanitize_for_espeak(text))
+            temp_file_path = temp_file.name
+        
+        # Call espeak-ng with the text file
+        subprocess.run([
+            "espeak-ng", 
+            "-v", voice, 
+            "-f", temp_file_path,
+            "-w", output_path,
+            f"-s{speed}", 
+            f"-p{pitch}",
+            f"-g{gap}"
+        ], check=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        
+        # Remove the temporary file
+        os.unlink(temp_file_path)
         
+        # Verify the output file exists and has content
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+            return True
+        else:
+            logger.error(f"Speech synthesis produced empty file: {output_path}")
+            return False
+    
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error in speech synthesis: {e}")
+        logger.error(f"STDERR: {e.stderr.decode('utf-8', errors='replace')}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error in speech synthesis: {e}")
+        return False
+
+def convert_chapters_to_audio(chapters_dir, output_audio_dir, voice="en", speed=170, pitch=50, gap=5, progress_callback=None):
+    """Convert all chapter text files to audio files."""
+    ensure_directory(output_audio_dir)
+    
+    # Get all chapter files
+    chapter_files = [f for f in os.listdir(chapters_dir) if f.startswith('chapter_') and f.endswith('.txt')]
+    chapter_files.sort(key=lambda f: int(re.search(r'chapter_(\d+)', f).group(1)))
+    
+    total_chapters = len(chapter_files)
+    processed_chapters = 0
+    failed_chapters = 0
+    
+    for chapter_file in chapter_files:
+        chapter_path = os.path.join(chapters_dir, chapter_file)
+        chapter_num = int(re.search(r'chapter_(\d+)', chapter_file).group(1))
+        output_file = os.path.join(output_audio_dir, f"audio_chapter_{chapter_num:03d}.wav")
+        
+        logger.info(f"Converting chapter {chapter_num} to audio...")
+        
+        # Read the chapter text
+        with open(chapter_path, 'r', encoding='utf-8', errors='replace') as f:
+            chapter_text = f.read()
+        
+        # Split into sentences for better processing
+        sentences = split_into_natural_sentences(chapter_text)
+        combined_audio = AudioSegment.empty()
+        
+        # Process each sentence
+        for i, sentence in enumerate(sentences):
+            if not sentence.strip():
+                continue
+                
+            temp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+            temp_wav.close()
+            
+            try:
+                # Convert sentence to speech
+                if convert_text_to_speech(sentence, temp_wav.name, voice, speed, pitch, gap):
+                    sentence_audio = AudioSegment.from_wav(temp_wav.name)
+                    combined_audio += sentence_audio
+                    
+                    # Add a small pause between sentences
+                    combined_audio += AudioSegment.silent(duration=50)
+                else:
+                    logger.warning(f"Failed to convert sentence in chapter {chapter_num}: {sentence[:50]}...")
+            except Exception as e:
+                logger.error(f"Error processing sentence: {e}")
+            finally:
+                # Clean up temporary file
+                if os.path.exists(temp_wav.name):
+                    os.unlink(temp_wav.name)
+        
+        # Export the combined audio for this chapter
+        if len(combined_audio) > 0:
+            combined_audio.export(output_file, format='wav')
+            logger.info(f"Saved audio for chapter {chapter_num}")
+            processed_chapters += 1
+        else:
+            logger.error(f"No audio generated for chapter {chapter_num}")
+            failed_chapters += 1
+        
+        # Update progress
+        if progress_callback:
+            progress_callback((processed_chapters + failed_chapters) / total_chapters, 
+                             f"Processed {processed_chapters}/{total_chapters} chapters")
+    
+    return processed_chapters, failed_chapters
+
+def create_m4b_audiobook(input_audio_dir, ebook_path, output_dir, title=None, author=None, progress_callback=None):
+    """Create M4B audiobook from chapter audio files."""
+    ensure_directory(output_dir)
+    
+    # Extract base name from ebook path
+    base_name = os.path.splitext(os.path.basename(ebook_path))[0]
+    output_m4b = os.path.join(output_dir, f"{base_name}.m4b")
+    
+    # Get chapter files
+    chapter_files = [f for f in os.listdir(input_audio_dir) if f.startswith('audio_chapter_') and f.endswith('.wav')]
+    chapter_files.sort(key=lambda f: int(re.search(r'audio_chapter_(\d+)', f).group(1)))
+    
+    if not chapter_files:
+        logger.error("No audio chapter files found")
+        return None
+    
+    # Create temporary directory
+    temp_dir = tempfile.mkdtemp()
+    
+    try:
+        # Combine audio files
+        combined_wav = os.path.join(temp_dir, "combined.wav")
+        combined_audio = AudioSegment.empty()
+        
+        chapter_positions = []
+        current_position = 0
+        
+        for i, chapter_file in enumerate(chapter_files):
+            chapter_path = os.path.join(input_audio_dir, chapter_file)
+            logger.info(f"Adding chapter {i+1}/{len(chapter_files)} to audiobook")
+            
+            try:
+                audio = AudioSegment.from_wav(chapter_path)
+                chapter_positions.append((current_position, len(audio), f"Chapter {i+1}"))
+                combined_audio += audio
+                current_position += len(audio)
+                
+                # Add silence between chapters
+                if i < len(chapter_files) - 1:
+                    silence = AudioSegment.silent(duration=1000)  # 1 second
+                    combined_audio += silence
+                    current_position += 1000
+            except Exception as e:
+                logger.error(f"Error processing audio file {chapter_file}: {e}")
+        
+        # Export combined audio
+        combined_audio.export(combined_wav, format="wav")
+        
+        # Extract cover
+        cover_image = extract_metadata_and_cover(ebook_path)
+        
+        # Create metadata file
+        metadata_file = os.path.join(temp_dir, "metadata.txt")
+        with open(metadata_file, 'w') as f:
+            f.write(';FFMETADATA1\n')
+            if title:
+                f.write(f"title={title}\n")
+            if author:
+                f.write(f"artist={author}\n")
+                
+            # Add chapters
+            for i, (start, duration, title) in enumerate(chapter_positions):
+                f.write(f'[CHAPTER]\nTIMEBASE=1/1000\nSTART={start}\n')
+                f.write(f'END={start + duration}\ntitle={title}\n')
+        
+        # Create M4B file with ffmpeg
         ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
-        if cover_image:
+        
+        if cover_image and os.path.exists(cover_image):
             ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
             ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
         else:
             ffmpeg_cmd += ['-map', '0:a']
         
-        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
-        ffmpeg_cmd += [output_m4b]
-
+        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k', output_m4b]
+        
+        # Execute ffmpeg command
         try:
-            subprocess.run(ffmpeg_cmd, check=True)
+            subprocess.run(ffmpeg_cmd, check=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+            logger.info(f"M4B file created successfully: {output_m4b}")
         except subprocess.CalledProcessError as e:
-            print("Metadata adding didn't work trying with only the cover art and no Metadata.")
-            ffmpeg_cmd = ""
-            ffmpeg_cmd = ['ffmpeg', '-i', combined_wav]
-            if cover_image:
-                print("Found Cover art")
-                ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
-                ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
-            else:
-                ffmpeg_cmd += ['-map', '0:a']
-
-            ffmpeg_cmd += ['-c:a', 'aac', '-b:a', '192k']
+            logger.error(f"Error creating M4B file: {e}")
+            logger.error(f"STDERR: {e.stderr.decode('utf-8', errors='replace')}")
+            
+            # Try simplified approach
+            logger.info("Trying simplified M4B creation...")
+            simple_cmd = ['ffmpeg', '-i', combined_wav, '-c:a', 'aac', '-b:a', '192k', output_m4b]
             try:
-                subprocess.run(ffmpeg_cmd, check=True)
+                subprocess.run(simple_cmd, check=True)
+                logger.info(f"M4B file created with simplified method: {output_m4b}")
             except subprocess.CalledProcessError as e:
-                print("Cover art adding didn't work, trying without any metadata or cover art.")
-                ffmpeg_cmd = ""
-                ffmpeg_cmd = ['ffmpeg', '-i', combined_wav]
-                ffmpeg_cmd += ['-map', '0:a']
-                ffmpeg_cmd += ['-c:a', 'aac', '-b:a', '192k']
-                try:
-                    subprocess.run(ffmpeg_cmd, check=True)
-                except subprocess.CalledProcessError:
-                    print("Failed to create M4B file. Trying to at least save the audio.")
-                try:
-                    ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-c:a', 'aac', '-b:a', '192k', output_m4b]
-                    subprocess.run(ffmpeg_cmd, check=True)
-                except subprocess.CalledProcessError as e:
-                    print(f"Final attempt failed: {e}")
-        print(f"M4B file created successfully at {output_m4b}")
-
-
-    chapter_files = sorted([os.path.join(input_dir, f) for f in os.listdir(input_dir) if f.endswith('.wav')], key=sort_key)
-    temp_dir = tempfile.gettempdir()
-    temp_combined_wav = os.path.join(temp_dir, 'combined.wav')
-    metadata_file = os.path.join(temp_dir, 'metadata.txt')
-    cover_image = extract_metadata_and_cover(ebook_file)
-    output_m4b = os.path.join(output_dir, os.path.splitext(os.path.basename(ebook_file))[0] + '.m4b')
-
-    combine_wav_files(chapter_files, temp_combined_wav)
-    generate_ffmpeg_metadata(chapter_files, metadata_file)
-    create_m4b(temp_combined_wav, metadata_file, cover_image, output_m4b)
-
-    if os.path.exists(temp_combined_wav):
-        os.remove(temp_combined_wav)
-    if os.path.exists(metadata_file):
-        os.remove(metadata_file)
-    if cover_image and os.path.exists(cover_image):
-        os.remove(cover_image)
-
-def create_chapter_labeled_book(ebook_file_path):
-    def ensure_directory(directory_path):
-        if not os.path.exists(directory_path):
-            os.makedirs(directory_path)
-            print(f"Created directory: {directory_path}")
-
-    ensure_directory(os.path.join(".", 'Working_files', 'Book'))
-
-    def convert_to_epub(input_path, output_path):
-        try:
-            subprocess.run(['ebook-convert', input_path, output_path], check=True)
-        except subprocess.CalledProcessError as e:
-            print(f"An error occurred while converting the eBook: {e}")
-            return False
-        return True
-
-    def save_chapters_as_text(epub_path):
-        directory = os.path.join(".", "Working_files", "temp_ebook")
-        ensure_directory(directory)
-
-        book = epub.read_epub(epub_path)
-
-        previous_filename = ''
-        chapter_counter = 0
-
-        for item in book.get_items():
-            if item.get_type() == ebooklib.ITEM_DOCUMENT:
-                soup = BeautifulSoup(item.get_content(), 'html.parser')
-                text = soup.get_text()
-
-                if text.strip():
-                    if len(text) < 2300 and previous_filename:
-                        with open(previous_filename, 'a', encoding='utf-8') as file:
-                            file.write('\n' + text)
-                    else:
-                        previous_filename = os.path.join(directory, f"chapter_{chapter_counter}.txt")
-                        chapter_counter += 1
-                        with open(previous_filename, 'w', encoding='utf-8') as file:
-                            file.write(text)
-                            print(f"Saved chapter: {previous_filename}")
-
-    input_ebook = ebook_file_path
-    output_epub = os.path.join(".", "Working_files", "temp.epub")
-
-    if os.path.exists(output_epub):
-        os.remove(output_epub)
-        print(f"File {output_epub} has been removed.")
+                logger.error(f"Simplified M4B creation also failed: {e}")
+                return None
+    
+    finally:
+        # Clean up temporary directory
+        shutil.rmtree(temp_dir)
+    
+    if os.path.exists(output_m4b) and os.path.getsize(output_m4b) > 0:
+        return output_m4b
     else:
-        print(f"The file {output_epub} does not exist.")
-
-    if convert_to_epub(input_ebook, output_epub):
-        save_chapters_as_text(output_epub)
-
-    # nltk.download('punkt')
-
-    def process_chapter_files(folder_path, output_csv):
-        with open(output_csv, 'w', newline='', encoding='utf-8') as csvfile:
-            writer = csv.writer(csvfile)
-            writer.writerow(['Text', 'Start Location', 'End Location', 'Is Quote', 'Speaker', 'Chapter'])
-
-            chapter_files = sorted(os.listdir(folder_path), key=lambda x: int(x.split('_')[1].split('.')[0]))
-            for filename in chapter_files:
-                if filename.startswith('chapter_') and filename.endswith('.txt'):
-                    chapter_number = int(filename.split('_')[1].split('.')[0])
-                    file_path = os.path.join(folder_path, filename)
-
-                    try:
-                        with open(file_path, 'r', encoding='utf-8') as file:
-                            text = file.read()
-                            if text:
-                                text = "NEWCHAPTERABC" + text
-                            sentences = nltk.tokenize.sent_tokenize(text)
-                            for sentence in sentences:
-                                start_location = text.find(sentence)
-                                end_location = start_location + len(sentence)
-                                writer.writerow([sentence, start_location, end_location, 'True', 'Narrator', chapter_number])
-                    except Exception as e:
-                        print(f"Error processing file {filename}: {e}")
-
-    folder_path = os.path.join(".", "Working_files", "temp_ebook")
-    output_csv = os.path.join(".", "Working_files", "Book", "Other_book.csv")
-
-    process_chapter_files(folder_path, output_csv)
-
-    def sort_key(filename):
-        match = re.search(r'chapter_(\d+)\.txt', filename)
-        return int(match.group(1)) if match else 0
-
-    def combine_chapters(input_folder, output_file):
-        os.makedirs(os.path.dirname(output_file), exist_ok=True)
-
-        files = [f for f in os.listdir(input_folder) if f.endswith('.txt')]
-        sorted_files = sorted(files, key=sort_key)
-
-        with open(output_file, 'w', encoding='utf-8') as outfile:
-            for i, filename in enumerate(sorted_files):
-                with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as infile:
-                    outfile.write(infile.read())
-                    if i < len(sorted_files) - 1:
-                        outfile.write("\nNEWCHAPTERABC\n")
-
-    input_folder = os.path.join(".", 'Working_files', 'temp_ebook')
-    output_file = os.path.join(".", 'Working_files', 'Book', 'Chapter_Book.txt')
-
-    combine_chapters(input_folder, output_file)
-
-    ensure_directory(os.path.join(".", "Working_files", "Book"))
-
-def sanitize_sentence(sentence):
-    # Replace or remove problematic characters that could cause issues in any language
-    sanitized = sentence.replace('--', ' ').replace('"', '').replace("'", "")
-    return sanitized
-
-def convert_chapters_to_audio_espeak(chapters_dir, output_audio_dir, speed="170", pitch="50", voice="en"):
-    if not os.path.exists(output_audio_dir):
-        os.makedirs(output_audio_dir)
-
-    for chapter_file in sorted(os.listdir(chapters_dir)):
-        if chapter_file.endswith('.txt'):
-            match = re.search(r"chapter_(\d+).txt", chapter_file)
-            if match:
-                chapter_num = int(match.group(1))
-            else:
-                print(f"Skipping file {chapter_file} as it does not match the expected format.")
-                continue
-
-            chapter_path = os.path.join(chapters_dir, chapter_file)
-            output_file_name = f"audio_chapter_{chapter_num}.wav"
-            output_file_path = os.path.join(output_audio_dir, output_file_name)
-
-            with open(chapter_path, 'r', encoding='utf-8') as file:
-                chapter_text = file.read()
-                sentences = nltk.tokenize.sent_tokenize(chapter_text)
-                combined_audio = AudioSegment.empty()
-
-                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
-                    success = False
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_wav:
-                        try:
-                            subprocess.run(["espeak-ng", "-v", voice, "-w", temp_wav.name, f"-s{speed}", f"-p{pitch}", sentence], check=True)
-                            success = True
-                        except subprocess.CalledProcessError:
-                            # If it fails, try with the sanitized sentence
-                            sanitized_sentence = sanitize_sentence(sentence)
-                            try:
-                                subprocess.run(["espeak-ng", "-v", voice, "-w", temp_wav.name, f"-s{speed}", f"-p{pitch}", sanitized_sentence], check=True)
-                                success = True
-                                print(f"Sanitized sentence used for: {sentence}")
-                            except subprocess.CalledProcessError as e:
-                                print(f"Failed to convert sentence to audio: {sentence}")
-                                print(f"Error: {e}")
-
-                        if success and os.path.getsize(temp_wav.name) > 0:
-                            combined_audio += AudioSegment.from_wav(temp_wav.name)
-                        else:
-                            print(f"Skipping sentence due to failure or empty WAV: {sentence}")
-                        os.remove(temp_wav.name)
-
-                combined_audio.export(output_file_path, format='wav')
-                print(f"Converted chapter {chapter_num} to audio.")
-
-
-def convert_ebook_to_audio(ebook_file, speed, pitch, voice, progress=gr.Progress()):
-    ebook_file_path = ebook_file.name
-    working_files = os.path.join(".", "Working_files", "temp_ebook")
-    full_folder_working_files = os.path.join(".", "Working_files")
-    chapters_directory = os.path.join(".", "Working_files", "temp_ebook")
-    output_audio_directory = os.path.join(".", 'Chapter_wav_files')
-    remove_folder_with_contents(full_folder_working_files)
-    remove_folder_with_contents(output_audio_directory)
-
-    try:
-        progress(0.1, desc="Creating chapter-labeled book")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-
-    create_chapter_labeled_book(ebook_file_path)
-    audiobook_output_path = os.path.join(".", "Audiobooks")
-
-    try:
-        progress(0.3, desc="Converting chapters to audio")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-
-    convert_chapters_to_audio_espeak(chapters_directory, output_audio_directory, speed, pitch, voice.split()[0])
+        logger.error("M4B file was not created or is empty")
+        return None
 
+# Main conversion function
+def convert_ebook_to_audiobook(ebook_file, speed, pitch, voice, gap, progress=None):
+    """Main function to convert ebook to audiobook."""
+    start_time = time.time()
+    
+    # Initialize directories
+    base_dir = os.path.abspath(os.path.dirname(__file__))
+    working_dir = os.path.join(base_dir, "Working_files")
+    chapters_dir = os.path.join(working_dir, "chapters")
+    audio_dir = os.path.join(base_dir, "Chapter_wav_files")
+    output_dir = os.path.join(base_dir, "Audiobooks")
+    
+    # Ensure output directory exists
+    ensure_directory(output_dir)
+    
+    # Clean up previous files
+    remove_directory(working_dir)
+    remove_directory(audio_dir)
+    
+    # Create necessary directories
+    ensure_directory(working_dir)
+    ensure_directory(chapters_dir)
+    ensure_directory(audio_dir)
+    
+    ebook_path = ebook_file.name
+    ebook_name = os.path.basename(ebook_path)
+    
     try:
-        progress(0.9, desc="Creating M4B from chapters")
+        # Extract basic metadata if possible
+        try:
+            meta_result = subprocess.run(['ebook-meta', ebook_path], 
+                                       stdout=subprocess.PIPE, text=True, check=False)
+            title_match = re.search(r'Title\s+:\s+(.*)', meta_result.stdout)
+            author_match = re.search(r'Author\(s\)\s+:\s+(.*)', meta_result.stdout)
+            title = title_match.group(1) if title_match else None
+            author = author_match.group(1) if author_match else None
+        except Exception as e:
+            logger.warning(f"Could not extract metadata: {e}")
+            title = author = None
+        
+        # Process ebook to chapters
+        if progress:
+            progress(0.1, desc="Extracting chapters from ebook")
+        
+        num_chapters = process_ebook_to_chapters(ebook_path, chapters_dir)
+        
+        if num_chapters == 0:
+            return f"Failed to extract chapters from {ebook_name}", None
+        
+        # Convert chapters to audio
+        if progress:
+            progress(0.3, desc="Converting text to speech")
+        
+        processed, failed = convert_chapters_to_audio(
+            chapters_dir, 
+            audio_dir, 
+            voice.split()[0], 
+            int(speed), 
+            int(pitch),
+            int(gap),
+            lambda prog, desc: progress(0.3 + prog * 0.6, desc=desc) if progress else None
+        )
+        
+        if processed == 0:
+            return f"Failed to convert any chapters to audio for {ebook_name}", None
+        
+        # Create M4B audiobook
+        if progress:
+            progress(0.9, desc="Creating M4B audiobook")
+        
+        m4b_path = create_m4b_audiobook(audio_dir, ebook_path, output_dir, title, author)
+        
+        if not m4b_path:
+            return f"Failed to create M4B file for {ebook_name}", None
+        
+        # Conversion complete
+        elapsed_time = time.time() - start_time
+        
+        if progress:
+            progress(1.0, desc="Conversion complete")
+        
+        return f"Audiobook created: {os.path.basename(m4b_path)} (in {elapsed_time:.1f} seconds)", m4b_path
+    
     except Exception as e:
-        print(f"Error updating progress: {e}")
-
-    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)
-
-    m4b_filename = os.path.splitext(os.path.basename(ebook_file_path))[0] + '.m4b'
-    m4b_filepath = os.path.join(audiobook_output_path, m4b_filename)
+        logger.error(f"Error converting ebook: {e}", exc_info=True)
+        return f"Error: {str(e)}", None
 
+# Utility functions for Gradio interface
+def get_available_voices():
+    """Get list of available espeak-ng voices."""
     try:
-        progress(1.0, desc="Conversion complete")
+        result = subprocess.run(['espeak-ng', '--voices'], 
+                              stdout=subprocess.PIPE, text=True, check=True)
+        lines = result.stdout.splitlines()[1:]  # Skip header
+        
+        voices = []
+        for line in lines:
+            parts = line.split()
+            if len(parts) > 3:
+                voice_id = parts[3]  # Language code
+                description = ' '.join(parts[3:])  # Description
+                voices.append(f"{voice_id} ({description})")
+        
+        return sorted(voices)
     except Exception as e:
-        print(f"Error updating progress: {e}")
-    print(f"Audiobook created at {m4b_filepath}")
-    return f"Audiobook created at {m4b_filepath}", m4b_filepath
-
-def list_audiobook_files(audiobook_folder):
+        logger.error(f"Error getting voices: {e}")
+        # Return some default voices as fallback
+        return ["en (English)", "en-us (American English)", "en-gb (British English)"]
+
+def list_audiobooks():
+    """List all audiobooks in the output directory."""
+    output_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), "Audiobooks")
+    ensure_directory(output_dir)
+    
     files = []
-    for filename in os.listdir(audiobook_folder):
+    for filename in os.listdir(output_dir):
         if filename.endswith('.m4b'):
-            files.append(os.path.join(audiobook_folder, filename))
-    return files
-
-def download_audiobooks():
-    audiobook_output_path = os.path.join(".", "Audiobooks")
-    return list_audiobook_files(audiobook_output_path)
-
-def get_available_voices():
-    result = subprocess.run(['espeak-ng', '--voices'], stdout=subprocess.PIPE, text=True)
-    lines = result.stdout.splitlines()[1:]  # Skip the header line
-    voices = []
-    for line in lines:
-        parts = line.split()
-        if len(parts) > 1:
-            voice_name = parts[1]
-            description = ' '.join(parts[2:])
-            voices.append((voice_name, description))
-    return voices
-
-theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="blue",
-    neutral_hue="blue",
-    text_size=gr.themes.sizes.text_md,
-)
-
-# Gradio UI setup
-with gr.Blocks(theme=theme) as demo:
-    gr.Markdown(
-    """
-    # eBook to Audiobook Converter
+            filepath = os.path.join(output_dir, filename)
+            files.append(filepath)
     
-    Convert your eBooks into audiobooks using eSpeak-NG.
-
-    This interface is based on [ebook2audiobookEspeak](https://github.com/DrewThomasson/ebook2audiobookEspeak).
-    """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=3):
-            ebook_file = gr.File(label="eBook File")
-            speed = gr.Slider(minimum=80, maximum=450, value=170, step=1, label="Speed")
-            pitch = gr.Slider(minimum=0, maximum=99, value=50, step=1, label="Pitch")
-            voices = get_available_voices()
-            voice_choices = [f"{voice} ({desc})" for voice, desc in voices]
-            voice_dropdown = gr.Dropdown(choices=voice_choices, label="Select Voice", value=voice_choices[0])
-
-    convert_btn = gr.Button("Convert to Audiobook", variant="primary")
-    output = gr.Textbox(label="Conversion Status")
-    audio_player = gr.Audio(label="Audiobook Player", type="filepath")
-    download_btn = gr.Button("Download Audiobook Files")
-    download_files = gr.File(label="Download Files", interactive=False)
-
-    convert_btn.click(
-        convert_ebook_to_audio,
-        inputs=[ebook_file, speed, pitch, voice_dropdown],
-        outputs=[output, audio_player]
-    )
-
-    download_btn.click(
-        download_audiobooks,
-        outputs=[download_files]
+    return sorted(files)
+
+# Gradio interface (continued)
+def create_gradio_interface(port=7860):
+    """Create and launch Gradio interface."""
+    # Create theme
+    theme = gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="green",
+        neutral_hue="slate",
+        text_size=gr.themes.sizes.text_md,
     )
+    
+    # Create interface
+    with gr.Blocks(theme=theme, title="eBook to Audiobook Converter") as demo:
+        gr.Markdown(
+        """
+        # 📚 eBook to Audiobook Converter
+        
+        Convert any eBook format (EPUB, MOBI, PDF, etc.) to an M4B audiobook using eSpeak-NG.
+        
+        ## Features
+        - Automatic chapter detection
+        - Natural sentence splitting
+        - Multiple voice and language options
+        - Customizable speech settings
+        """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                ebook_file = gr.File(label="eBook File", file_types=[".epub", ".mobi", ".azw", ".azw3", ".fb2", ".txt", ".pdf"])
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        speed = gr.Slider(minimum=80, maximum=450, value=170, step=1, 
+                                     label="Speech Speed", info="Higher values = faster speech")
+                    with gr.Column(scale=1):
+                        pitch = gr.Slider(minimum=0, maximum=99, value=50, step=1, 
+                                     label="Voice Pitch", info="Higher values = higher pitch")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gap = gr.Slider(minimum=0, maximum=20, value=5, step=1, 
+                                    label="Pause Length", info="Pause between words (ms)")
+                    with gr.Column(scale=1):
+                        voice_dropdown = gr.Dropdown(
+                            choices=get_available_voices(), 
+                            label="Voice", 
+                            value="en (English)",
+                            info="Select language and voice variant"
+                        )
+                
+                convert_btn = gr.Button("Convert to Audiobook", variant="primary")
+                cancel_btn = gr.Button("Cancel Conversion", variant="stop")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                conversion_status = gr.Textbox(label="Conversion Status", interactive=False)
+            with gr.Column(scale=1):
+                audio_player = gr.Audio(label="Preview", type="filepath", interactive=False)
+        
+        gr.Markdown("## Download Audiobooks")
+        with gr.Row():
+            refresh_btn = gr.Button("Refresh List")
+            download_btn = gr.Button("Download Selected File")
+        
+        audiobook_files = gr.Dropdown(
+            choices=list_audiobooks(),
+            label="Available Audiobooks",
+            value=None,
+            interactive=True
+        )
+        
+        # Define conversion task state
+        conversion_task = {"running": False, "thread": None}
+        
+        # Handle events
+        def start_conversion(ebook_file, speed, pitch, voice, gap, progress=gr.Progress()):
+            # Check if already running
+            if conversion_task["running"]:
+                return "A conversion is already in progress. Please wait or cancel it.", None
+            
+            if not ebook_file:
+                return "Please select an eBook file first.", None
+            
+            conversion_task["running"] = True
+            result, output_path = convert_ebook_to_audiobook(ebook_file, speed, pitch, voice, gap, progress)
+            conversion_task["running"] = False
+            
+            return result, output_path
+        
+        def cancel_current_conversion():
+            if conversion_task["running"]:
+                conversion_task["running"] = False
+                return "Conversion cancelled."
+            else:
+                return "No conversion is currently running."
+        
+        def refresh_audiobook_list():
+            return gr.Dropdown.update(choices=list_audiobooks())
+        
+        # Connect events
+        convert_btn.click(
+            start_conversion,
+            inputs=[ebook_file, speed, pitch, voice_dropdown, gap],
+            outputs=[conversion_status, audio_player]
+        )
+        
+        cancel_btn.click(
+            cancel_current_conversion,
+            outputs=[conversion_status]
+        )
+        
+        refresh_btn.click(
+            refresh_audiobook_list,
+            outputs=[audiobook_files]
+        )
+        
+        download_btn.click(
+            lambda x: x, 
+            inputs=[audiobook_files],
+            outputs=[audiobook_files]
+        )
+        
+        ebook_file.upload(
+            lambda: "eBook uploaded successfully",
+            outputs=[conversion_status]
+        )
+        
+    # Launch the interface
+    demo.launch(server_port=port, share=True)
+    return demo
+
+# Command-line interface
+def main():
+    """Command-line entry point."""
+    parser = argparse.ArgumentParser(description='Convert eBooks to Audiobooks')
+    parser.add_argument('--gui', action='store_true', help='Launch graphical interface')
+    parser.add_argument('--port', type=int, default=7860, help='Port for web interface')
+    parser.add_argument('--ebook', type=str, help='Path to eBook file')
+    parser.add_argument('--voice', default='en', help='eSpeak voice to use')
+    parser.add_argument('--speed', type=int, default=170, help='Speech speed')
+    parser.add_argument('--pitch', type=int, default=50, help='Voice pitch')
+    parser.add_argument('--gap', type=int, default=5, help='Word gap')
+    args = parser.parse_args()
+    
+    if args.gui:
+        create_gradio_interface(port=args.port)
+    elif args.ebook:
+        # Create a temporary file-like object for the ebook path
+        class FilePath:
+            def __init__(self, path):
+                self.name = path
+        
+        print(f"Converting {args.ebook} to audiobook...")
+        result, output_path = convert_ebook_to_audiobook(
+            FilePath(args.ebook), 
+            args.speed, 
+            args.pitch, 
+            args.voice,
+            args.gap
+        )
+        print(result)
+    else:
+        # Default to GUI if no arguments
+        create_gradio_interface()
 
-#demo.launch(share=True)
-demo.launch() # Removing share = True cause huggingface space
+if __name__ == "__main__":
+    main()