Upload 8 files

legacy/custom_model_ebook2audiobookXTTS.py

@@ -0,0 +1,484 @@
+print("starting...")
+
+import os
+import shutil
+import subprocess
+import re
+from pydub import AudioSegment
+import tempfile
+from pydub import AudioSegment
+import os
+import nltk
+from nltk.tokenize import sent_tokenize
+import sys
+import torch
+from TTS.api import TTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from tqdm import tqdm
+
+nltk.download('punkt')  # Make sure to download the necessary models
+def is_folder_empty(folder_path):
+    if os.path.exists(folder_path) and os.path.isdir(folder_path):
+        # List directory contents
+        if not os.listdir(folder_path):
+            return True  # The folder is empty
+        else:
+            return False  # The folder is not empty
+    else:
+        print(f"The path {folder_path} is not a valid folder.")
+        return None  # The path is not a valid folder
+
+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}")
+
+
+
+
+def wipe_folder(folder_path):
+    # Check if the folder exists
+    if not os.path.exists(folder_path):
+        print(f"The folder {folder_path} does not exist.")
+        return
+
+    # Iterate over all the items in the given folder
+    for item in os.listdir(folder_path):
+        item_path = os.path.join(folder_path, item)
+        # If it's a file, remove it and print a message
+        if os.path.isfile(item_path):
+            os.remove(item_path)
+            print(f"Removed file: {item_path}")
+        # If it's a directory, remove it recursively and print a message
+        elif os.path.isdir(item_path):
+            shutil.rmtree(item_path)
+            print(f"Removed directory and its contents: {item_path}")
+    
+    print(f"All contents wiped from {folder_path}.")
+
+
+# Example usage
+# folder_to_wipe = 'path_to_your_folder'
+# wipe_folder(folder_to_wipe)
+
+
+def create_m4b_from_chapters(input_dir, ebook_file, output_dir):
+    # Function to sort chapters based on their numeric order
+    def sort_key(chapter_file):
+        numbers = re.findall(r'\d+', chapter_file)
+        return int(numbers[0]) if numbers else 0
+
+    # Extract metadata and cover image from the eBook file
+    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
+        except Exception as e:
+            print(f"Error extracting eBook metadata or cover: {e}")
+        return None
+    # Combine WAV files into a single file
+    def combine_wav_files(chapter_files, output_path):
+    	# Initialize an empty audio segment
+    	combined_audio = AudioSegment.empty()
+
+    	# Sequentially append each file to the combined_audio
+    	for chapter_file in chapter_files:
+    		audio_segment = AudioSegment.from_wav(chapter_file)
+    		combined_audio += audio_segment
+    	# Export the combined audio to the output file path
+    	combined_audio.export(output_path, format='wav')
+    	print(f"Combined audio saved to {output_path}")
+
+    # Function to generate metadata for M4B 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
+
+    # Generate the final M4B file using ffmpeg
+    def create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
+        
+        ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
+        if cover_image:
+            ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
+        else:
+            ffmpeg_cmd += ['-map', '0:a']
+        
+        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
+        if cover_image:
+            ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
+        ffmpeg_cmd += [output_m4b]
+
+        subprocess.run(ffmpeg_cmd, check=True)
+
+
+
+    # Main logic
+    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)
+
+    # Cleanup
+    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)
+
+# Example usage
+# create_m4b_from_chapters('path_to_chapter_wavs', 'path_to_ebook_file', 'path_to_output_dir')
+
+
+
+
+
+
+#this code right here isnt the book grabbing thing but its before to refrence in ordero to create the sepecial chapter labeled book thing with calibre idk some systems cant seem to get it so just in case but the next bit of code after this is the book grabbing code with booknlp 
+import os
+import subprocess
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+import re
+import csv
+import nltk
+
+# Only run the main script if Value is True
+def create_chapter_labeled_book(ebook_file_path):
+    # Function to ensure the existence of a directory
+    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):
+        # Convert the ebook to EPUB format using Calibre's ebook-convert
+        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):
+        # Create the directory if it doesn't exist
+        directory = os.path.join(".", "Working_files", "temp_ebook")
+        ensure_directory(directory)
+
+        # Open the EPUB file
+        book = epub.read_epub(epub_path)
+
+        previous_chapter_text = ''
+        previous_filename = ''
+        chapter_counter = 0
+
+        # Iterate through the items in the EPUB file
+        for item in book.get_items():
+            if item.get_type() == ebooklib.ITEM_DOCUMENT:
+                # Use BeautifulSoup to parse HTML content
+                soup = BeautifulSoup(item.get_content(), 'html.parser')
+                text = soup.get_text()
+
+                # Check if the text is not empty
+                if text.strip():
+                    if len(text) < 2300 and previous_filename:
+                        # Append text to the previous chapter if it's short
+                        with open(previous_filename, 'a', encoding='utf-8') as file:
+                            file.write('\n' + text)
+                    else:
+                        # Create a new chapter file and increment the counter
+                        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}")
+
+    # Example usage
+    input_ebook = ebook_file_path  # Replace with your 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.")
+    else:
+        print(f"The file {output_epub} does not exist.")
+
+    if convert_to_epub(input_ebook, output_epub):
+        save_chapters_as_text(output_epub)
+
+    # Download the necessary NLTK data (if not already present)
+    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)
+            # Write the header row
+            writer.writerow(['Text', 'Start Location', 'End Location', 'Is Quote', 'Speaker', 'Chapter'])
+
+            # Process each chapter file
+            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()
+                            # Insert "NEWCHAPTERABC" at the beginning of each chapter's text
+                            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}")
+
+    # Example usage
+    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):
+        """Extract chapter number for sorting."""
+        match = re.search(r'chapter_(\d+)\.txt', filename)
+        return int(match.group(1)) if match else 0
+
+    def combine_chapters(input_folder, output_file):
+        # Create the output folder if it doesn't exist
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+        # List all txt files and sort them by chapter number
+        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:  # Specify UTF-8 encoding here
+            for i, filename in enumerate(sorted_files):
+                with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as infile:  # And here
+                    outfile.write(infile.read())
+                    # Add the marker unless it's the last file
+                    if i < len(sorted_files) - 1:
+                        outfile.write("\nNEWCHAPTERABC\n")
+
+    # Paths
+    input_folder = os.path.join(".", 'Working_files', 'temp_ebook')
+    output_file = os.path.join(".", 'Working_files', 'Book', 'Chapter_Book.txt')
+
+
+    # Combine the chapters
+    combine_chapters(input_folder, output_file)
+
+    ensure_directory(os.path.join(".", "Working_files", "Book"))
+
+
+#create_chapter_labeled_book()
+
+
+
+
+import os
+import subprocess
+import sys
+import torchaudio
+
+# Check if Calibre's ebook-convert tool is installed
+def calibre_installed():
+    try:
+        subprocess.run(['ebook-convert', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return True
+    except FileNotFoundError:
+        print("Calibre is not installed. Please install Calibre for this functionality.")
+        return False
+
+
+import os
+import torch
+from TTS.api import TTS
+from nltk.tokenize import sent_tokenize
+from pydub import AudioSegment
+# Assuming split_long_sentence and wipe_folder are defined elsewhere in your code
+
+default_target_voice_path = "default_voice.wav"  # Ensure this is a valid path
+default_language_code = "en"
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def combine_wav_files(input_directory, output_directory, file_name):
+    # Ensure that the output directory exists, create it if necessary
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Specify the output file path
+    output_file_path = os.path.join(output_directory, file_name)
+
+    # Initialize an empty audio segment
+    combined_audio = AudioSegment.empty()
+
+    # Get a list of all .wav files in the specified input directory and sort them
+    input_file_paths = sorted(
+        [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith(".wav")],
+        key=lambda f: int(''.join(filter(str.isdigit, f)))
+    )
+
+    # Sequentially append each file to the combined_audio
+    for input_file_path in input_file_paths:
+        audio_segment = AudioSegment.from_wav(input_file_path)
+        combined_audio += audio_segment
+
+    # Export the combined audio to the output file path
+    combined_audio.export(output_file_path, format='wav')
+
+    print(f"Combined audio saved to {output_file_path}")
+
+# Function to split long strings into parts
+def split_long_sentence(sentence, max_length=249, max_pauses=10):
+    """
+    Splits a sentence into parts based on length or number of pauses without recursion.
+    
+    :param sentence: The sentence to split.
+    :param max_length: Maximum allowed length of a sentence.
+    :param max_pauses: Maximum allowed number of pauses in a sentence.
+    :return: A list of sentence parts that meet the criteria.
+    """
+    parts = []
+    while len(sentence) > max_length or sentence.count(',') + sentence.count(';') + sentence.count('.') > max_pauses:
+        possible_splits = [i for i, char in enumerate(sentence) if char in ',;.' and i < max_length]
+        if possible_splits:
+            # Find the best place to split the sentence, preferring the last possible split to keep parts longer
+            split_at = possible_splits[-1] + 1
+        else:
+            # If no punctuation to split on within max_length, split at max_length
+            split_at = max_length
+        
+        # Split the sentence and add the first part to the list
+        parts.append(sentence[:split_at].strip())
+        sentence = sentence[split_at:].strip()
+    
+    # Add the remaining part of the sentence
+    parts.append(sentence)
+    return parts
+
+"""
+if 'tts' not in locals():
+	tts = TTS(selected_tts_model, progress_bar=True).to(device)
+"""
+from tqdm import tqdm
+
+# Convert chapters to audio using XTTS
+def convert_chapters_to_audio(chapters_dir, output_audio_dir, target_voice_path=None, language=None, custom_model=None):
+    if custom_model:
+        print("Loading custom model...")
+        config = XttsConfig()
+        config.load_json(custom_model['config'])
+        model = Xtts.init_from_config(config)
+        model.load_checkpoint(config, checkpoint_path=custom_model['model'], vocab_path=custom_model['vocab'], use_deepspeed=False)
+        model.to(device)
+        print("Computing speaker latents...")
+        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=[target_voice_path])
+    else:
+        selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+        tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            if custom_model:
+                                out = model.inference(fragment, language, gpt_cond_latent, speaker_embedding, temperature=0.7)
+                                torchaudio.save(fragment_file_path, torch.tensor(out["wav"]).unsqueeze(0), 24000)
+                            else:
+                                speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                                language_code = language if language else default_language_code
+                                tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+
+# Main execution flow
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python script.py <ebook_file_path> [target_voice_file_path] [language] [custom_model_path] [custom_config_path] [custom_vocab_path]")
+        sys.exit(1)
+
+    ebook_file_path = sys.argv[1]
+    target_voice = sys.argv[2] if len(sys.argv) > 2 else None
+    language = sys.argv[3] if len(sys.argv) > 3 else None
+
+    custom_model = None
+    if len(sys.argv) > 6:
+        custom_model = {
+            'model': sys.argv[4],
+            'config': sys.argv[5],
+            'vocab': sys.argv[6]
+        }
+
+    if not calibre_installed():
+        sys.exit(1)
+
+    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')
+
+    print("Wiping and removing Working_files folder...")
+    remove_folder_with_contents(full_folder_working_files)
+
+    print("Wiping and removing chapter_wav_files folder...")
+    remove_folder_with_contents(output_audio_directory)
+
+    create_chapter_labeled_book(ebook_file_path)
+    audiobook_output_path = os.path.join(".", "Audiobooks")
+    print(f"{chapters_directory}||||{output_audio_directory}|||||{target_voice}")
+    convert_chapters_to_audio(chapters_directory, output_audio_directory, target_voice, language, custom_model)
+    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)

legacy/custom_model_ebook2audiobookXTTS_gradio.py

@@ -0,0 +1,609 @@
+print("starting...")
+
+import os
+import shutil
+import subprocess
+import re
+from pydub import AudioSegment
+import tempfile
+from pydub import AudioSegment
+import os
+import nltk
+from nltk.tokenize import sent_tokenize
+import sys
+import torch
+from TTS.api import TTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from tqdm import tqdm
+
+nltk.download('punkt')  # Make sure to download the necessary models
+
+import gradio as gr
+from gradio import Progress
+
+
+def is_folder_empty(folder_path):
+    if os.path.exists(folder_path) and os.path.isdir(folder_path):
+        # List directory contents
+        if not os.listdir(folder_path):
+            return True  # The folder is empty
+        else:
+            return False  # The folder is not empty
+    else:
+        print(f"The path {folder_path} is not a valid folder.")
+        return None  # The path is not a valid folder
+
+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}")
+
+
+
+
+def wipe_folder(folder_path):
+    # Check if the folder exists
+    if not os.path.exists(folder_path):
+        print(f"The folder {folder_path} does not exist.")
+        return
+
+    # Iterate over all the items in the given folder
+    for item in os.listdir(folder_path):
+        item_path = os.path.join(folder_path, item)
+        # If it's a file, remove it and print a message
+        if os.path.isfile(item_path):
+            os.remove(item_path)
+            print(f"Removed file: {item_path}")
+        # If it's a directory, remove it recursively and print a message
+        elif os.path.isdir(item_path):
+            shutil.rmtree(item_path)
+            print(f"Removed directory and its contents: {item_path}")
+    
+    print(f"All contents wiped from {folder_path}.")
+
+
+# Example usage
+# folder_to_wipe = 'path_to_your_folder'
+# wipe_folder(folder_to_wipe)
+
+
+def create_m4b_from_chapters(input_dir, ebook_file, output_dir):
+    # Function to sort chapters based on their numeric order
+    def sort_key(chapter_file):
+        numbers = re.findall(r'\d+', chapter_file)
+        return int(numbers[0]) if numbers else 0
+
+    # Extract metadata and cover image from the eBook file
+    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
+        except Exception as e:
+            print(f"Error extracting eBook metadata or cover: {e}")
+        return None
+    # Combine WAV files into a single file
+    def combine_wav_files(chapter_files, output_path):
+        # Initialize an empty audio segment
+        combined_audio = AudioSegment.empty()
+
+        # Sequentially append each file to the combined_audio
+        for chapter_file in chapter_files:
+            audio_segment = AudioSegment.from_wav(chapter_file)
+            combined_audio += audio_segment
+        # Export the combined audio to the output file path
+        combined_audio.export(output_path, format='wav')
+        print(f"Combined audio saved to {output_path}")
+
+    # Function to generate metadata for M4B 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
+
+    # Generate the final M4B file using ffmpeg
+    def create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
+        
+        ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
+        if cover_image:
+            ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
+        else:
+            ffmpeg_cmd += ['-map', '0:a']
+        
+        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
+        if cover_image:
+            ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
+        ffmpeg_cmd += [output_m4b]
+
+        subprocess.run(ffmpeg_cmd, check=True)
+
+
+
+    # Main logic
+    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)
+
+    # Cleanup
+    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)
+
+# Example usage
+# create_m4b_from_chapters('path_to_chapter_wavs', 'path_to_ebook_file', 'path_to_output_dir')
+
+
+
+
+
+
+#this code right here isnt the book grabbing thing but its before to refrence in ordero to create the sepecial chapter labeled book thing with calibre idk some systems cant seem to get it so just in case but the next bit of code after this is the book grabbing code with booknlp 
+import os
+import subprocess
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+import re
+import csv
+import nltk
+
+# Only run the main script if Value is True
+def create_chapter_labeled_book(ebook_file_path):
+    # Function to ensure the existence of a directory
+    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):
+        # Convert the ebook to EPUB format using Calibre's ebook-convert
+        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):
+        # Create the directory if it doesn't exist
+        directory = os.path.join(".", "Working_files", "temp_ebook")
+        ensure_directory(directory)
+
+        # Open the EPUB file
+        book = epub.read_epub(epub_path)
+
+        previous_chapter_text = ''
+        previous_filename = ''
+        chapter_counter = 0
+
+        # Iterate through the items in the EPUB file
+        for item in book.get_items():
+            if item.get_type() == ebooklib.ITEM_DOCUMENT:
+                # Use BeautifulSoup to parse HTML content
+                soup = BeautifulSoup(item.get_content(), 'html.parser')
+                text = soup.get_text()
+
+                # Check if the text is not empty
+                if text.strip():
+                    if len(text) < 2300 and previous_filename:
+                        # Append text to the previous chapter if it's short
+                        with open(previous_filename, 'a', encoding='utf-8') as file:
+                            file.write('\n' + text)
+                    else:
+                        # Create a new chapter file and increment the counter
+                        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}")
+
+    # Example usage
+    input_ebook = ebook_file_path  # Replace with your 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.")
+    else:
+        print(f"The file {output_epub} does not exist.")
+
+    if convert_to_epub(input_ebook, output_epub):
+        save_chapters_as_text(output_epub)
+
+    # Download the necessary NLTK data (if not already present)
+    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)
+            # Write the header row
+            writer.writerow(['Text', 'Start Location', 'End Location', 'Is Quote', 'Speaker', 'Chapter'])
+
+            # Process each chapter file
+            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()
+                            # Insert "NEWCHAPTERABC" at the beginning of each chapter's text
+                            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}")
+
+    # Example usage
+    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):
+        """Extract chapter number for sorting."""
+        match = re.search(r'chapter_(\d+)\.txt', filename)
+        return int(match.group(1)) if match else 0
+
+    def combine_chapters(input_folder, output_file):
+        # Create the output folder if it doesn't exist
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+        # List all txt files and sort them by chapter number
+        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:  # Specify UTF-8 encoding here
+            for i, filename in enumerate(sorted_files):
+                with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as infile:  # And here
+                    outfile.write(infile.read())
+                    # Add the marker unless it's the last file
+                    if i < len(sorted_files) - 1:
+                        outfile.write("\nNEWCHAPTERABC\n")
+
+    # Paths
+    input_folder = os.path.join(".", 'Working_files', 'temp_ebook')
+    output_file = os.path.join(".", 'Working_files', 'Book', 'Chapter_Book.txt')
+
+
+    # Combine the chapters
+    combine_chapters(input_folder, output_file)
+
+    ensure_directory(os.path.join(".", "Working_files", "Book"))
+
+
+#create_chapter_labeled_book()
+
+
+
+
+import os
+import subprocess
+import sys
+import torchaudio
+
+# Check if Calibre's ebook-convert tool is installed
+def calibre_installed():
+    try:
+        subprocess.run(['ebook-convert', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return True
+    except FileNotFoundError:
+        print("Calibre is not installed. Please install Calibre for this functionality.")
+        return False
+
+
+import os
+import torch
+from TTS.api import TTS
+from nltk.tokenize import sent_tokenize
+from pydub import AudioSegment
+# Assuming split_long_sentence and wipe_folder are defined elsewhere in your code
+
+default_target_voice_path = "default_voice.wav"  # Ensure this is a valid path
+default_language_code = "en"
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def combine_wav_files(input_directory, output_directory, file_name):
+    # Ensure that the output directory exists, create it if necessary
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Specify the output file path
+    output_file_path = os.path.join(output_directory, file_name)
+
+    # Initialize an empty audio segment
+    combined_audio = AudioSegment.empty()
+
+    # Get a list of all .wav files in the specified input directory and sort them
+    input_file_paths = sorted(
+        [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith(".wav")],
+        key=lambda f: int(''.join(filter(str.isdigit, f)))
+    )
+
+    # Sequentially append each file to the combined_audio
+    for input_file_path in input_file_paths:
+        audio_segment = AudioSegment.from_wav(input_file_path)
+        combined_audio += audio_segment
+
+    # Export the combined audio to the output file path
+    combined_audio.export(output_file_path, format='wav')
+
+    print(f"Combined audio saved to {output_file_path}")
+
+# Function to split long strings into parts
+def split_long_sentence(sentence, max_length=249, max_pauses=10):
+    """
+    Splits a sentence into parts based on length or number of pauses without recursion.
+    
+    :param sentence: The sentence to split.
+    :param max_length: Maximum allowed length of a sentence.
+    :param max_pauses: Maximum allowed number of pauses in a sentence.
+    :return: A list of sentence parts that meet the criteria.
+    """
+    parts = []
+    while len(sentence) > max_length or sentence.count(',') + sentence.count(';') + sentence.count('.') > max_pauses:
+        possible_splits = [i for i, char in enumerate(sentence) if char in ',;.' and i < max_length]
+        if possible_splits:
+            # Find the best place to split the sentence, preferring the last possible split to keep parts longer
+            split_at = possible_splits[-1] + 1
+        else:
+            # If no punctuation to split on within max_length, split at max_length
+            split_at = max_length
+        
+        # Split the sentence and add the first part to the list
+        parts.append(sentence[:split_at].strip())
+        sentence = sentence[split_at:].strip()
+    
+    # Add the remaining part of the sentence
+    parts.append(sentence)
+    return parts
+
+"""
+if 'tts' not in locals():
+    tts = TTS(selected_tts_model, progress_bar=True).to(device)
+"""
+from tqdm import tqdm
+
+# Convert chapters to audio using XTTS
+
+def convert_chapters_to_audio_custom_model(chapters_dir, output_audio_dir, target_voice_path=None, language=None, custom_model=None):
+    if custom_model:
+        print("Loading custom model...")
+        config = XttsConfig()
+        config.load_json(custom_model['config'])
+        model = Xtts.init_from_config(config)
+        model.load_checkpoint(config, checkpoint_path=custom_model['model'], vocab_path=custom_model['vocab'], use_deepspeed=False)
+        model.to(device)
+        print("Computing speaker latents...")
+        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=[target_voice_path])
+    else:
+        selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+        tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            if custom_model:
+                                out = model.inference(fragment, language, gpt_cond_latent, speaker_embedding, temperature=0.7)
+                                torchaudio.save(fragment_file_path, torch.tensor(out["wav"]).unsqueeze(0), 24000)
+                            else:
+                                speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                                language_code = language if language else default_language_code
+                                tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+
+
+def convert_chapters_to_audio_standard_model(chapters_dir, output_audio_dir, target_voice_path=None, language=None):
+    selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+    tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                            language_code = language if language else default_language_code
+                            tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+
+
+# Define the functions to be used in the Gradio interface
+def convert_ebook_to_audio(ebook_file, target_voice_file, language, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file, progress=gr.Progress()):
+    ebook_file_path = ebook_file.name
+    target_voice = target_voice_file.name if target_voice_file else None
+    custom_model = None
+    if use_custom_model and custom_model_file and custom_config_file and custom_vocab_file:
+        custom_model = {
+            'model': custom_model_file.name,
+            'config': custom_config_file.name,
+            'vocab': custom_vocab_file.name
+        }
+    
+    try:
+        progress(0, desc="Starting conversion")
+    except Exception as e:
+        print(f"Error updating progress: {e}")
+    
+    if not calibre_installed():
+        return "Calibre is not installed."
+    
+    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}")
+    
+    if use_custom_model:
+        convert_chapters_to_audio_custom_model(chapters_directory, output_audio_directory, target_voice, language, custom_model)
+    else:
+        convert_chapters_to_audio_standard_model(chapters_directory, output_audio_directory, target_voice, language)
+    
+    try:
+        progress(0.9, desc="Creating M4B from chapters")
+    except Exception as e:
+        print(f"Error updating progress: {e}")
+    
+    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)
+    
+    # Get the name of the created M4B file
+    m4b_filename = os.path.splitext(os.path.basename(ebook_file_path))[0] + '.m4b'
+    m4b_filepath = os.path.join(audiobook_output_path, m4b_filename)
+
+    try:
+        progress(1.0, desc="Conversion complete")
+    except Exception as e:
+        print(f"Error updating progress: {e}")
+    
+    return f"Audiobook created at {m4b_filepath}", m4b_filepath
+
+language_options = [
+    "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"
+]
+
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="blue",
+    neutral_hue="blue",
+    text_size=gr.themes.sizes.text_md,
+)
+
+with gr.Blocks(theme=theme) as demo:
+    gr.Markdown(
+    """
+    # eBook to Audiobook Converter
+    
+    Transform your eBooks into immersive audiobooks with optional custom TTS models.
+    """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            ebook_file = gr.File(label="eBook File")
+            target_voice_file = gr.File(label="Target Voice File (Optional)")
+            language = gr.Dropdown(label="Language", choices=language_options, value="en")
+        
+        with gr.Column(scale=3):
+            use_custom_model = gr.Checkbox(label="Use Custom Model")
+            custom_model_file = gr.File(label="Custom Model File (Optional)", visible=False)
+            custom_config_file = gr.File(label="Custom Config File (Optional)", visible=False)
+            custom_vocab_file = gr.File(label="Custom Vocab File (Optional)", visible=False)
+
+    convert_btn = gr.Button("Convert to Audiobook", variant="primary")
+    output = gr.Textbox(label="Conversion Status")
+    audio_player = gr.Audio(label="Audiobook Player", type="filepath")
+
+    convert_btn.click(
+        convert_ebook_to_audio,
+        inputs=[ebook_file, target_voice_file, language, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file],
+        outputs=[output, audio_player]
+    )
+
+    use_custom_model.change(
+        lambda x: [gr.update(visible=x)] * 3,
+        inputs=[use_custom_model],
+        outputs=[custom_model_file, custom_config_file, custom_vocab_file]
+    )
+
+demo.launch(share=False)

legacy/custom_model_ebook2audiobookXTTS_with_link_gradio.py

@@ -0,0 +1,700 @@
+print("starting...")
+
+import os
+import shutil
+import subprocess
+import re
+from pydub import AudioSegment
+import tempfile
+from pydub import AudioSegment
+import os
+import nltk
+from nltk.tokenize import sent_tokenize
+import sys
+import torch
+from TTS.api import TTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from tqdm import tqdm
+import gradio as gr
+from gradio import Progress
+import urllib.request
+import zipfile
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Device selected is: {device}")
+
+nltk.download('punkt')  # Make sure to download the necessary models
+
+
+def download_and_extract_zip(url, extract_to='.'):
+    try:
+        # Ensure the directory exists
+        os.makedirs(extract_to, exist_ok=True)
+        
+        zip_path = os.path.join(extract_to, 'model.zip')
+        
+        # Download with progress bar
+        with tqdm(unit='B', unit_scale=True, miniters=1, desc="Downloading Model") as t:
+            def reporthook(blocknum, blocksize, totalsize):
+                t.total = totalsize
+                t.update(blocknum * blocksize - t.n)
+
+            urllib.request.urlretrieve(url, zip_path, reporthook=reporthook)
+        print(f"Downloaded zip file to {zip_path}")
+        
+        # Unzipping with progress bar
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            files = zip_ref.namelist()
+            with tqdm(total=len(files), unit="file", desc="Extracting Files") as t:
+                for file in files:
+                    if not file.endswith('/'):  # Skip directories
+                        # Extract the file to the temporary directory
+                        extracted_path = zip_ref.extract(file, extract_to)
+                        # Move the file to the base directory
+                        base_file_path = os.path.join(extract_to, os.path.basename(file))
+                        os.rename(extracted_path, base_file_path)
+                    t.update(1)
+        
+        # Cleanup: Remove the ZIP file and any empty folders
+        os.remove(zip_path)
+        for root, dirs, files in os.walk(extract_to, topdown=False):
+            for name in dirs:
+                os.rmdir(os.path.join(root, name))
+        print(f"Extracted files to {extract_to}")
+        
+        # Check if all required files are present
+        required_files = ['model.pth', 'config.json', 'vocab.json_']
+        missing_files = [file for file in required_files if not os.path.exists(os.path.join(extract_to, file))]
+        
+        if not missing_files:
+            print("All required files (model.pth, config.json, vocab.json_) found.")
+        else:
+            print(f"Missing files: {', '.join(missing_files)}")
+    
+    except Exception as e:
+        print(f"Failed to download or extract zip file: {e}")
+
+
+
+def is_folder_empty(folder_path):
+    if os.path.exists(folder_path) and os.path.isdir(folder_path):
+        # List directory contents
+        if not os.listdir(folder_path):
+            return True  # The folder is empty
+        else:
+            return False  # The folder is not empty
+    else:
+        print(f"The path {folder_path} is not a valid folder.")
+        return None  # The path is not a valid folder
+
+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}")
+
+
+
+
+def wipe_folder(folder_path):
+    # Check if the folder exists
+    if not os.path.exists(folder_path):
+        print(f"The folder {folder_path} does not exist.")
+        return
+
+    # Iterate over all the items in the given folder
+    for item in os.listdir(folder_path):
+        item_path = os.path.join(folder_path, item)
+        # If it's a file, remove it and print a message
+        if os.path.isfile(item_path):
+            os.remove(item_path)
+            print(f"Removed file: {item_path}")
+        # If it's a directory, remove it recursively and print a message
+        elif os.path.isdir(item_path):
+            shutil.rmtree(item_path)
+            print(f"Removed directory and its contents: {item_path}")
+    
+    print(f"All contents wiped from {folder_path}.")
+
+
+# Example usage
+# folder_to_wipe = 'path_to_your_folder'
+# wipe_folder(folder_to_wipe)
+
+
+def create_m4b_from_chapters(input_dir, ebook_file, output_dir):
+    # Function to sort chapters based on their numeric order
+    def sort_key(chapter_file):
+        numbers = re.findall(r'\d+', chapter_file)
+        return int(numbers[0]) if numbers else 0
+
+    # Extract metadata and cover image from the eBook file
+    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
+        except Exception as e:
+            print(f"Error extracting eBook metadata or cover: {e}")
+        return None
+    # Combine WAV files into a single file
+    def combine_wav_files(chapter_files, output_path):
+        # Initialize an empty audio segment
+        combined_audio = AudioSegment.empty()
+
+        # Sequentially append each file to the combined_audio
+        for chapter_file in chapter_files:
+            audio_segment = AudioSegment.from_wav(chapter_file)
+            combined_audio += audio_segment
+        # Export the combined audio to the output file path
+        combined_audio.export(output_path, format='wav')
+        print(f"Combined audio saved to {output_path}")
+
+    # Function to generate metadata for M4B 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
+
+    # Generate the final M4B file using ffmpeg
+    def create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
+        
+        ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
+        if cover_image:
+            ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
+        else:
+            ffmpeg_cmd += ['-map', '0:a']
+        
+        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
+        if cover_image:
+            ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
+        ffmpeg_cmd += [output_m4b]
+
+        subprocess.run(ffmpeg_cmd, check=True)
+
+
+
+    # Main logic
+    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)
+
+    # Cleanup
+    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)
+
+# Example usage
+# create_m4b_from_chapters('path_to_chapter_wavs', 'path_to_ebook_file', 'path_to_output_dir')
+
+
+
+
+
+
+#this code right here isnt the book grabbing thing but its before to refrence in ordero to create the sepecial chapter labeled book thing with calibre idk some systems cant seem to get it so just in case but the next bit of code after this is the book grabbing code with booknlp 
+import os
+import subprocess
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+import re
+import csv
+import nltk
+
+# Only run the main script if Value is True
+def create_chapter_labeled_book(ebook_file_path):
+    # Function to ensure the existence of a directory
+    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):
+        # Convert the ebook to EPUB format using Calibre's ebook-convert
+        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):
+        # Create the directory if it doesn't exist
+        directory = os.path.join(".", "Working_files", "temp_ebook")
+        ensure_directory(directory)
+
+        # Open the EPUB file
+        book = epub.read_epub(epub_path)
+
+        previous_chapter_text = ''
+        previous_filename = ''
+        chapter_counter = 0
+
+        # Iterate through the items in the EPUB file
+        for item in book.get_items():
+            if item.get_type() == ebooklib.ITEM_DOCUMENT:
+                # Use BeautifulSoup to parse HTML content
+                soup = BeautifulSoup(item.get_content(), 'html.parser')
+                text = soup.get_text()
+
+                # Check if the text is not empty
+                if text.strip():
+                    if len(text) < 2300 and previous_filename:
+                        # Append text to the previous chapter if it's short
+                        with open(previous_filename, 'a', encoding='utf-8') as file:
+                            file.write('\n' + text)
+                    else:
+                        # Create a new chapter file and increment the counter
+                        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}")
+
+    # Example usage
+    input_ebook = ebook_file_path  # Replace with your 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.")
+    else:
+        print(f"The file {output_epub} does not exist.")
+
+    if convert_to_epub(input_ebook, output_epub):
+        save_chapters_as_text(output_epub)
+
+    # Download the necessary NLTK data (if not already present)
+    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)
+            # Write the header row
+            writer.writerow(['Text', 'Start Location', 'End Location', 'Is Quote', 'Speaker', 'Chapter'])
+
+            # Process each chapter file
+            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()
+                            # Insert "NEWCHAPTERABC" at the beginning of each chapter's text
+                            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}")
+
+    # Example usage
+    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):
+        """Extract chapter number for sorting."""
+        match = re.search(r'chapter_(\d+)\.txt', filename)
+        return int(match.group(1)) if match else 0
+
+    def combine_chapters(input_folder, output_file):
+        # Create the output folder if it doesn't exist
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+        # List all txt files and sort them by chapter number
+        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:  # Specify UTF-8 encoding here
+            for i, filename in enumerate(sorted_files):
+                with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as infile:  # And here
+                    outfile.write(infile.read())
+                    # Add the marker unless it's the last file
+                    if i < len(sorted_files) - 1:
+                        outfile.write("\nNEWCHAPTERABC\n")
+
+    # Paths
+    input_folder = os.path.join(".", 'Working_files', 'temp_ebook')
+    output_file = os.path.join(".", 'Working_files', 'Book', 'Chapter_Book.txt')
+
+
+    # Combine the chapters
+    combine_chapters(input_folder, output_file)
+
+    ensure_directory(os.path.join(".", "Working_files", "Book"))
+
+
+#create_chapter_labeled_book()
+
+
+
+
+import os
+import subprocess
+import sys
+import torchaudio
+
+# Check if Calibre's ebook-convert tool is installed
+def calibre_installed():
+    try:
+        subprocess.run(['ebook-convert', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return True
+    except FileNotFoundError:
+        print("Calibre is not installed. Please install Calibre for this functionality.")
+        return False
+
+
+import os
+import torch
+from TTS.api import TTS
+from nltk.tokenize import sent_tokenize
+from pydub import AudioSegment
+# Assuming split_long_sentence and wipe_folder are defined elsewhere in your code
+
+default_target_voice_path = "default_voice.wav"  # Ensure this is a valid path
+default_language_code = "en"
+def combine_wav_files(input_directory, output_directory, file_name):
+    # Ensure that the output directory exists, create it if necessary
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Specify the output file path
+    output_file_path = os.path.join(output_directory, file_name)
+
+    # Initialize an empty audio segment
+    combined_audio = AudioSegment.empty()
+
+    # Get a list of all .wav files in the specified input directory and sort them
+    input_file_paths = sorted(
+        [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith(".wav")],
+        key=lambda f: int(''.join(filter(str.isdigit, f)))
+    )
+
+    # Sequentially append each file to the combined_audio
+    for input_file_path in input_file_paths:
+        audio_segment = AudioSegment.from_wav(input_file_path)
+        combined_audio += audio_segment
+
+    # Export the combined audio to the output file path
+    combined_audio.export(output_file_path, format='wav')
+
+    print(f"Combined audio saved to {output_file_path}")
+
+# Function to split long strings into parts
+def split_long_sentence(sentence, max_length=249, max_pauses=10):
+    """
+    Splits a sentence into parts based on length or number of pauses without recursion.
+    
+    :param sentence: The sentence to split.
+    :param max_length: Maximum allowed length of a sentence.
+    :param max_pauses: Maximum allowed number of pauses in a sentence.
+    :return: A list of sentence parts that meet the criteria.
+    """
+    parts = []
+    while len(sentence) > max_length or sentence.count(',') + sentence.count(';') + sentence.count('.') > max_pauses:
+        possible_splits = [i for i, char in enumerate(sentence) if char in ',;.' and i < max_length]
+        if possible_splits:
+            # Find the best place to split the sentence, preferring the last possible split to keep parts longer
+            split_at = possible_splits[-1] + 1
+        else:
+            # If no punctuation to split on within max_length, split at max_length
+            split_at = max_length
+        
+        # Split the sentence and add the first part to the list
+        parts.append(sentence[:split_at].strip())
+        sentence = sentence[split_at:].strip()
+    
+    # Add the remaining part of the sentence
+    parts.append(sentence)
+    return parts
+
+"""
+if 'tts' not in locals():
+    tts = TTS(selected_tts_model, progress_bar=True).to(device)
+"""
+from tqdm import tqdm
+
+# Convert chapters to audio using XTTS
+
+def convert_chapters_to_audio_custom_model(chapters_dir, output_audio_dir, target_voice_path=None, language=None, custom_model=None):
+
+    if target_voice_path==None:
+        target_voice_path = default_target_voice_path
+
+    if custom_model:
+        print("Loading custom model...")
+        config = XttsConfig()
+        config.load_json(custom_model['config'])
+        model = Xtts.init_from_config(config)
+        model.load_checkpoint(config, checkpoint_path=custom_model['model'], vocab_path=custom_model['vocab'], use_deepspeed=False)
+        model.to(device)
+        print("Computing speaker latents...")
+        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=[target_voice_path])
+    else:
+        selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+        tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            if custom_model:
+                                out = model.inference(fragment, language, gpt_cond_latent, speaker_embedding, temperature=0.7)
+                                torchaudio.save(fragment_file_path, torch.tensor(out["wav"]).unsqueeze(0), 24000)
+                            else:
+                                speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                                language_code = language if language else default_language_code
+                                tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+
+
+def convert_chapters_to_audio_standard_model(chapters_dir, output_audio_dir, target_voice_path=None, language=None):
+    selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+    tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                            language_code = language if language else default_language_code
+                            tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+
+
+# Define the functions to be used in the Gradio interface
+def convert_ebook_to_audio(ebook_file, target_voice_file, language, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file, custom_model_url=None, progress=gr.Progress()):
+    ebook_file_path = ebook_file.name
+    target_voice = target_voice_file.name if target_voice_file else None
+    custom_model = None
+
+
+    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)
+
+    if use_custom_model and custom_model_file and custom_config_file and custom_vocab_file:
+        custom_model = {
+            'model': custom_model_file.name,
+            'config': custom_config_file.name,
+            'vocab': custom_vocab_file.name
+        }
+    if use_custom_model and custom_model_url:
+        print(f"Received custom model URL: {custom_model_url}")
+        download_dir = os.path.join(".", "Working_files", "custom_model")
+        download_and_extract_zip(custom_model_url, download_dir)
+        custom_model = {
+            'model': os.path.join(download_dir, 'model.pth'),
+            'config': os.path.join(download_dir, 'config.json'),
+            'vocab': os.path.join(download_dir, 'vocab.json_')
+        }
+    
+    try:
+        progress(0, desc="Starting conversion")
+    except Exception as e:
+        print(f"Error updating progress: {e}")
+    
+    if not calibre_installed():
+        return "Calibre is not installed."
+    
+    
+    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}")
+    
+    if use_custom_model:
+        convert_chapters_to_audio_custom_model(chapters_directory, output_audio_directory, target_voice, language, custom_model)
+    else:
+        convert_chapters_to_audio_standard_model(chapters_directory, output_audio_directory, target_voice, language)
+    
+    try:
+        progress(0.9, desc="Creating M4B from chapters")
+    except Exception as e:
+        print(f"Error updating progress: {e}")
+    
+    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)
+    
+    # Get the name of the created M4B file
+    m4b_filename = os.path.splitext(os.path.basename(ebook_file_path))[0] + '.m4b'
+    m4b_filepath = os.path.join(audiobook_output_path, m4b_filename)
+
+    try:
+        progress(1.0, desc="Conversion complete")
+    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):
+    # List all files in the audiobook folder
+    files = []
+    for filename in os.listdir(audiobook_folder):
+        if filename.endswith('.m4b'):  # Adjust the file extension as needed
+            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)
+
+
+language_options = [
+    "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"
+]
+
+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
+    
+    Transform your eBooks into immersive audiobooks with optional custom TTS models.
+    """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            ebook_file = gr.File(label="eBook File")
+            target_voice_file = gr.File(label="Target Voice File (Optional)")
+            language = gr.Dropdown(label="Language", choices=language_options, value="en")
+        
+        with gr.Column(scale=3):
+            use_custom_model = gr.Checkbox(label="Use Custom Model")
+            custom_model_file = gr.File(label="Custom Model File (Optional)", visible=False)
+            custom_config_file = gr.File(label="Custom Config File (Optional)", visible=False)
+            custom_vocab_file = gr.File(label="Custom Vocab File (Optional)", visible=False)
+            custom_model_url = gr.Textbox(label="Custom Model Zip URL (Optional)", visible=False)
+
+    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, target_voice_file, language, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file, custom_model_url],
+        outputs=[output, audio_player]
+    )
+
+    use_custom_model.change(
+        lambda x: [gr.update(visible=x)] * 4,
+        inputs=[use_custom_model],
+        outputs=[custom_model_file, custom_config_file, custom_vocab_file, custom_model_url]
+    )
+
+    download_btn.click(
+        download_audiobooks,
+        outputs=[download_files]
+    )
+
+demo.launch(share=True)

legacy/ebook2audiobook.py

@@ -0,0 +1,462 @@
+print("starting...")
+
+import os
+import shutil
+import subprocess
+import re
+from pydub import AudioSegment
+import tempfile
+from pydub import AudioSegment
+import os
+import nltk
+from nltk.tokenize import sent_tokenize
+nltk.download('punkt')  # Make sure to download the necessary models
+def is_folder_empty(folder_path):
+    if os.path.exists(folder_path) and os.path.isdir(folder_path):
+        # List directory contents
+        if not os.listdir(folder_path):
+            return True  # The folder is empty
+        else:
+            return False  # The folder is not empty
+    else:
+        print(f"The path {folder_path} is not a valid folder.")
+        return None  # The path is not a valid folder
+
+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}")
+
+
+
+
+def wipe_folder(folder_path):
+    # Check if the folder exists
+    if not os.path.exists(folder_path):
+        print(f"The folder {folder_path} does not exist.")
+        return
+
+    # Iterate over all the items in the given folder
+    for item in os.listdir(folder_path):
+        item_path = os.path.join(folder_path, item)
+        # If it's a file, remove it and print a message
+        if os.path.isfile(item_path):
+            os.remove(item_path)
+            print(f"Removed file: {item_path}")
+        # If it's a directory, remove it recursively and print a message
+        elif os.path.isdir(item_path):
+            shutil.rmtree(item_path)
+            print(f"Removed directory and its contents: {item_path}")
+    
+    print(f"All contents wiped from {folder_path}.")
+
+
+# Example usage
+# folder_to_wipe = 'path_to_your_folder'
+# wipe_folder(folder_to_wipe)
+
+
+def create_m4b_from_chapters(input_dir, ebook_file, output_dir):
+    # Function to sort chapters based on their numeric order
+    def sort_key(chapter_file):
+        numbers = re.findall(r'\d+', chapter_file)
+        return int(numbers[0]) if numbers else 0
+
+    # Extract metadata and cover image from the eBook file
+    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
+        except Exception as e:
+            print(f"Error extracting eBook metadata or cover: {e}")
+        return None
+    # Combine WAV files into a single file
+    def combine_wav_files(chapter_files, output_path):
+    	# Initialize an empty audio segment
+    	combined_audio = AudioSegment.empty()
+
+    	# Sequentially append each file to the combined_audio
+    	for chapter_file in chapter_files:
+    		audio_segment = AudioSegment.from_wav(chapter_file)
+    		combined_audio += audio_segment
+    	# Export the combined audio to the output file path
+    	combined_audio.export(output_path, format='wav')
+    	print(f"Combined audio saved to {output_path}")
+
+    # Function to generate metadata for M4B 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
+
+    # Generate the final M4B file using ffmpeg
+    def create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
+        
+        ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
+        if cover_image:
+            ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
+        else:
+            ffmpeg_cmd += ['-map', '0:a']
+        
+        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
+        if cover_image:
+            ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
+        ffmpeg_cmd += [output_m4b]
+
+        subprocess.run(ffmpeg_cmd, check=True)
+
+
+
+    # Main logic
+    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)
+
+    # Cleanup
+    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)
+
+# Example usage
+# create_m4b_from_chapters('path_to_chapter_wavs', 'path_to_ebook_file', 'path_to_output_dir')
+
+
+
+
+
+
+#this code right here isnt the book grabbing thing but its before to refrence in ordero to create the sepecial chapter labeled book thing with calibre idk some systems cant seem to get it so just in case but the next bit of code after this is the book grabbing code with booknlp 
+import os
+import subprocess
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+import re
+import csv
+import nltk
+
+# Only run the main script if Value is True
+def create_chapter_labeled_book(ebook_file_path):
+    # Function to ensure the existence of a directory
+    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):
+        # Convert the ebook to EPUB format using Calibre's ebook-convert
+        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):
+        # Create the directory if it doesn't exist
+        directory = os.path.join(".", "Working_files", "temp_ebook")
+        ensure_directory(directory)
+
+        # Open the EPUB file
+        book = epub.read_epub(epub_path)
+
+        previous_chapter_text = ''
+        previous_filename = ''
+        chapter_counter = 0
+
+        # Iterate through the items in the EPUB file
+        for item in book.get_items():
+            if item.get_type() == ebooklib.ITEM_DOCUMENT:
+                # Use BeautifulSoup to parse HTML content
+                soup = BeautifulSoup(item.get_content(), 'html.parser')
+                text = soup.get_text()
+
+                # Check if the text is not empty
+                if text.strip():
+                    if len(text) < 2300 and previous_filename:
+                        # Append text to the previous chapter if it's short
+                        with open(previous_filename, 'a', encoding='utf-8') as file:
+                            file.write('\n' + text)
+                    else:
+                        # Create a new chapter file and increment the counter
+                        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}")
+
+    # Example usage
+    input_ebook = ebook_file_path  # Replace with your 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.")
+    else:
+        print(f"The file {output_epub} does not exist.")
+
+    if convert_to_epub(input_ebook, output_epub):
+        save_chapters_as_text(output_epub)
+
+    # Download the necessary NLTK data (if not already present)
+    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)
+            # Write the header row
+            writer.writerow(['Text', 'Start Location', 'End Location', 'Is Quote', 'Speaker', 'Chapter'])
+
+            # Process each chapter file
+            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()
+                            # Insert "NEWCHAPTERABC" at the beginning of each chapter's text
+                            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}")
+
+    # Example usage
+    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):
+        """Extract chapter number for sorting."""
+        match = re.search(r'chapter_(\d+)\.txt', filename)
+        return int(match.group(1)) if match else 0
+
+    def combine_chapters(input_folder, output_file):
+        # Create the output folder if it doesn't exist
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+        # List all txt files and sort them by chapter number
+        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:  # Specify UTF-8 encoding here
+            for i, filename in enumerate(sorted_files):
+                with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as infile:  # And here
+                    outfile.write(infile.read())
+                    # Add the marker unless it's the last file
+                    if i < len(sorted_files) - 1:
+                        outfile.write("\nNEWCHAPTERABC\n")
+
+    # Paths
+    input_folder = os.path.join(".", 'Working_files', 'temp_ebook')
+    output_file = os.path.join(".", 'Working_files', 'Book', 'Chapter_Book.txt')
+
+
+    # Combine the chapters
+    combine_chapters(input_folder, output_file)
+
+    ensure_directory(os.path.join(".", "Working_files", "Book"))
+
+
+#create_chapter_labeled_book()
+
+
+
+
+import os
+import subprocess
+import sys
+import torchaudio
+
+# Check if Calibre's ebook-convert tool is installed
+def calibre_installed():
+    try:
+        subprocess.run(['ebook-convert', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return True
+    except FileNotFoundError:
+        print("Calibre is not installed. Please install Calibre for this functionality.")
+        return False
+
+
+import os
+import torch
+from TTS.api import TTS
+from nltk.tokenize import sent_tokenize
+from pydub import AudioSegment
+# Assuming split_long_sentence and wipe_folder are defined elsewhere in your code
+
+default_target_voice_path = "default_voice.wav"  # Ensure this is a valid path
+default_language_code = "en"
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def combine_wav_files(input_directory, output_directory, file_name):
+    # Ensure that the output directory exists, create it if necessary
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Specify the output file path
+    output_file_path = os.path.join(output_directory, file_name)
+
+    # Initialize an empty audio segment
+    combined_audio = AudioSegment.empty()
+
+    # Get a list of all .wav files in the specified input directory and sort them
+    input_file_paths = sorted(
+        [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith(".wav")],
+        key=lambda f: int(''.join(filter(str.isdigit, f)))
+    )
+
+    # Sequentially append each file to the combined_audio
+    for input_file_path in input_file_paths:
+        audio_segment = AudioSegment.from_wav(input_file_path)
+        combined_audio += audio_segment
+
+    # Export the combined audio to the output file path
+    combined_audio.export(output_file_path, format='wav')
+
+    print(f"Combined audio saved to {output_file_path}")
+
+# Function to split long strings into parts
+def split_long_sentence(sentence, max_length=249, max_pauses=10):
+    """
+    Splits a sentence into parts based on length or number of pauses without recursion.
+    
+    :param sentence: The sentence to split.
+    :param max_length: Maximum allowed length of a sentence.
+    :param max_pauses: Maximum allowed number of pauses in a sentence.
+    :return: A list of sentence parts that meet the criteria.
+    """
+    parts = []
+    while len(sentence) > max_length or sentence.count(',') + sentence.count(';') + sentence.count('.') > max_pauses:
+        possible_splits = [i for i, char in enumerate(sentence) if char in ',;.' and i < max_length]
+        if possible_splits:
+            # Find the best place to split the sentence, preferring the last possible split to keep parts longer
+            split_at = possible_splits[-1] + 1
+        else:
+            # If no punctuation to split on within max_length, split at max_length
+            split_at = max_length
+        
+        # Split the sentence and add the first part to the list
+        parts.append(sentence[:split_at].strip())
+        sentence = sentence[split_at:].strip()
+    
+    # Add the remaining part of the sentence
+    parts.append(sentence)
+    return parts
+
+"""
+if 'tts' not in locals():
+	tts = TTS(selected_tts_model, progress_bar=True).to(device)
+"""
+from tqdm import tqdm
+
+# Convert chapters to audio using XTTS
+def convert_chapters_to_audio(chapters_dir, output_audio_dir, target_voice_path=None, language=None):
+    selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+    tts = TTS(selected_tts_model, progress_bar=False).to(device)  # Set progress_bar to False to avoid nested progress bars
+
+    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'):
+            # Extract chapter number from the filename
+            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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                # Use the specified language model for sentence tokenization
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = []
+                    if language == "en":
+                        fragments = split_long_sentence(sentence, max_length=249, max_pauses=10)
+                    if language == "it":
+                        fragments = split_long_sentence(sentence, max_length=213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "": #a hot fix to avoid blank fragments
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                            language_code = language if language else default_language_code
+                            tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+
+
+# Main execution flow
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python script.py <ebook_file_path> [target_voice_file_path]")
+        sys.exit(1)
+
+    ebook_file_path = sys.argv[1]
+    target_voice = sys.argv[2] if len(sys.argv) > 2 else None
+    language = sys.argv[3] if len(sys.argv) > 3 else None
+
+    if not calibre_installed():
+        sys.exit(1)
+
+    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')
+
+    print("Wiping and removeing Working_files folder...")
+    remove_folder_with_contents(full_folder_working_files)
+
+    print("Wiping and and removeing chapter_wav_files folder...")
+    remove_folder_with_contents(output_audio_directory)
+
+    create_chapter_labeled_book(ebook_file_path)
+    audiobook_output_path = os.path.join(".", "Audiobooks")
+    print(f"{chapters_directory}||||{output_audio_directory}|||||{target_voice}")
+    convert_chapters_to_audio(chapters_directory, output_audio_directory, target_voice, language)
+    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)

legacy/gradio_gui_with_email_and_que.py

@@ -0,0 +1,614 @@
+print("starting...")
+import ebooklib
+from ebooklib import epub
+
+import os
+import subprocess
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+import re
+import csv
+import nltk
+
+import os
+import subprocess
+import sys
+import torchaudio
+
+import os
+import torch
+from TTS.api import TTS
+from nltk.tokenize import sent_tokenize
+from pydub import AudioSegment
+
+from tqdm import tqdm
+
+
+
+import os
+import subprocess
+import ebooklib
+from ebooklib import epub
+from bs4 import BeautifulSoup
+import re
+import csv
+import nltk
+
+from bs4 import BeautifulSoup
+import os
+import shutil
+import subprocess
+import re
+from pydub import AudioSegment
+import tempfile
+import urllib.request
+import zipfile
+import requests
+from tqdm import tqdm
+import nltk
+from nltk.tokenize import sent_tokenize
+import torch
+import torchaudio
+import gradio as gr
+from threading import Lock, Thread
+from queue import Queue
+import smtplib
+from email.mime.text import MIMEText
+
+
+import os
+import shutil
+import subprocess
+import re
+from pydub import AudioSegment
+import tempfile
+from pydub import AudioSegment
+import os
+import nltk
+from nltk.tokenize import sent_tokenize
+import sys
+import torch
+from TTS.api import TTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from tqdm import tqdm
+import gradio as gr
+from gradio import Progress
+import urllib.request
+import zipfile
+
+
+default_target_voice_path = "default_voice.wav"  # Ensure this is a valid path
+default_language_code = "en"
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Device selected is: {device}")
+
+nltk.download('punkt')  # Ensure necessary models are downloaded
+
+# Global variables for queue management
+queue = Queue()
+queue_lock = Lock()
+
+# Function to send an email with the download link
+def send_email(to_address, download_link):
+    from_address = "your_email@example.com"  # Replace with your email
+    subject = "Your Audiobook is Ready"
+    body = f"Your audiobook has been processed. You can download it from the following link: {download_link}"
+    
+    msg = MIMEText(body)
+    msg['Subject'] = subject
+    msg['From'] = from_address
+    msg['To'] = to_address
+
+    try:
+        with smtplib.SMTP('smtp.example.com', 587) as server:  # Replace with your SMTP server details
+            server.starttls()
+            server.login(from_address, "your_password")  # Replace with your email password
+            server.sendmail(from_address, [to_address], msg.as_string())
+            print(f"Email sent to {to_address}")
+    except Exception as e:
+        print(f"Failed to send email: {e}")
+
+# Function to download and extract the custom model
+def download_and_extract_zip(url, extract_to='.'):
+    try:
+        os.makedirs(extract_to, exist_ok=True)
+        zip_path = os.path.join(extract_to, 'model.zip')
+        
+        with tqdm(unit='B', unit_scale=True, miniters=1, desc="Downloading Model") as t:
+            def reporthook(blocknum, blocksize, totalsize):
+                t.total = totalsize
+                t.update(blocknum * blocksize - t.n)
+            urllib.request.urlretrieve(url, zip_path, reporthook=reporthook)
+        print(f"Downloaded zip file to {zip_path}")
+        
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            files = zip_ref.namelist()
+            with tqdm(total=len(files), unit="file", desc="Extracting Files") as t:
+                for file in files:
+                    if not file.endswith('/'):
+                        extracted_path = zip_ref.extract(file, extract_to)
+                        base_file_path = os.path.join(extract_to, os.path.basename(file))
+                        os.rename(extracted_path, base_file_path)
+                    t.update(1)
+        
+        os.remove(zip_path)
+        for root, dirs, files in os.walk(extract_to, topdown=False):
+            for name in dirs:
+                os.rmdir(os.path.join(root, name))
+        print(f"Extracted files to {extract_to}")
+        
+        required_files = ['model.pth', 'config.json', 'vocab.json_']
+        missing_files = [file for file in required_files if not os.path.exists(os.path.join(extract_to, file))]
+        
+        if not missing_files:
+            print("All required files (model.pth, config.json, vocab.json_) found.")
+        else:
+            print(f"Missing files: {', '.join(missing_files)}")
+    
+    except Exception as e:
+        print(f"Failed to download or extract zip file: {e}")
+
+# Function to check if a folder is empty
+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
+
+# Function to remove a folder and its contents
+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}")
+
+# Function to wipe the contents of a folder
+def wipe_folder(folder_path):
+    if not os.path.exists(folder_path):
+        print(f"The folder {folder_path} does not exist.")
+        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)
+            print(f"Removed file: {item_path}")
+        elif os.path.isdir(item_path):
+            shutil.rmtree(item_path)
+            print(f"Removed directory and its contents: {item_path}")
+    
+    print(f"All contents wiped from {folder_path}.")
+
+# Function to create M4B from chapters
+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
+        except Exception as e:
+            print(f"Error extracting eBook metadata or cover: {e}")
+        return None
+
+    def combine_wav_files(chapter_files, output_path):
+        combined_audio = AudioSegment.empty()
+        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 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 create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
+        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
+        
+        ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
+        if cover_image:
+            ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
+        else:
+            ffmpeg_cmd += ['-map', '0:a']
+        
+        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
+        if cover_image:
+            ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
+        ffmpeg_cmd += [output_m4b]
+
+        subprocess.run(ffmpeg_cmd, check=True)
+
+    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)
+
+# Function to create chapter-labeled book
+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_chapter_text = ''
+        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.")
+    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"))
+
+# Function to combine WAV files
+def combine_wav_files(input_directory, output_directory, file_name):
+    os.makedirs(output_directory, exist_ok=True)
+    output_file_path = os.path.join(output_directory, file_name)
+    combined_audio = AudioSegment.empty()
+    input_file_paths = sorted(
+        [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith(".wav")],
+        key=lambda f: int(''.join(filter(str.isdigit, f)))
+    )
+    for input_file_path in input_file_paths:
+        audio_segment = AudioSegment.from_wav(input_file_path)
+        combined_audio += audio_segment
+    combined_audio.export(output_file_path, format='wav')
+    print(f"Combined audio saved to {output_file_path}")
+
+# Function to split long sentences
+def split_long_sentence(sentence, max_length=249, max_pauses=10):
+    parts = []
+    while len(sentence) > max_length or sentence.count(',') + sentence.count(';') + sentence.count('.') > max_pauses:
+        possible_splits = [i for i, char in enumerate(sentence) if char in ',;.' and i < max_length]
+        if possible_splits:
+            split_at = possible_splits[-1] + 1
+        else:
+            split_at = max_length
+        parts.append(sentence[:split_at].strip())
+        sentence = sentence[split_at:].strip()
+    parts.append(sentence)
+    return parts
+
+# Function to convert chapters to audio using custom model
+def convert_chapters_to_audio_custom_model(chapters_dir, output_audio_dir, target_voice_path=None, language=None, custom_model=None):
+    if target_voice_path is None:
+        target_voice_path = default_target_voice_path
+    if custom_model:
+        print("Loading custom model...")
+        config = XttsConfig()
+        config.load_json(custom_model['config'])
+        model = Xtts.init_from_config(config)
+        model.load_checkpoint(config, checkpoint_path=custom_model['model'], vocab_path=custom_model['vocab'], use_deepspeed=False)
+        model.device
+        print("Computing speaker latents...")
+        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=[target_voice_path])
+    else:
+        selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+        tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            if custom_model:
+                                out = model.inference(fragment, language, gpt_cond_latent, speaker_embedding, temperature=0.7)
+                                torchaudio.save(fragment_file_path, torch.tensor(out["wav"]).unsqueeze(0), 24000)
+                            else:
+                                speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                                language_code = language if language else default_language_code
+                                tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+# Function to convert chapters to audio using standard model
+def convert_chapters_to_audio_standard_model(chapters_dir, output_audio_dir, target_voice_path=None, language=None):
+    selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
+    tts = TTS(selected_tts_model, progress_bar=False).to(device)
+
+    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)
+            temp_audio_directory = os.path.join(".", "Working_files", "temp")
+            os.makedirs(temp_audio_directory, exist_ok=True)
+            temp_count = 0
+
+            with open(chapter_path, 'r', encoding='utf-8') as file:
+                chapter_text = file.read()
+                sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
+                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
+                    fragments = split_long_sentence(sentence, max_length=249 if language == "en" else 213, max_pauses=10)
+                    for fragment in fragments:
+                        if fragment != "":
+                            print(f"Generating fragment: {fragment}...")
+                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
+                            speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
+                            language_code = language if language else default_language_code
+                            tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code)
+                            temp_count += 1
+
+            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
+            wipe_folder(temp_audio_directory)
+            print(f"Converted chapter {chapter_num} to audio.")
+
+# Function to handle the processing of an eBook to an audiobook
+def process_request(ebook_file, target_voice, language, email, use_custom_model, custom_model):
+    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)
+
+    create_chapter_labeled_book(ebook_file.name)
+    audiobook_output_path = os.path.join(".", "Audiobooks")
+    
+    if use_custom_model:
+        convert_chapters_to_audio_custom_model(chapters_directory, output_audio_directory, target_voice, language, custom_model)
+    else:
+        convert_chapters_to_audio_standard_model(chapters_directory, output_audio_directory, target_voice, language)
+    
+    create_m4b_from_chapters(output_audio_directory, ebook_file.name, audiobook_output_path)
+
+    m4b_filepath = os.path.join(audiobook_output_path, os.path.splitext(os.path.basename(ebook_file.name))[0] + '.m4b')
+    
+    # Upload the final audiobook to file.io
+    with open(m4b_filepath, 'rb') as f:
+        response = requests.post('https://file.io', files={'file': f})
+        download_link = response.json().get('link', '')
+
+    # Send the download link to the user's email
+    if email and download_link:
+        send_email(email, download_link)
+
+    return download_link
+
+# Function to manage the queue and process each request sequentially
+def handle_queue():
+    while True:
+        ebook_file, target_voice, language, email, use_custom_model, custom_model = queue.get()
+        process_request(ebook_file, target_voice, language, email, use_custom_model, custom_model)
+        queue.task_done()
+
+# Start the queue handler thread
+thread = Thread(target=handle_queue, daemon=True)
+thread.start()
+
+# Gradio function to add a request to the queue
+def enqueue_request(ebook_file, target_voice_file, language, email, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file, custom_model_url=None):
+    target_voice = target_voice_file.name if target_voice_file else None
+    custom_model = None
+
+    if use_custom_model and custom_model_file and custom_config_file and custom_vocab_file:
+        custom_model = {
+            'model': custom_model_file.name,
+            'config': custom_config_file.name,
+            'vocab': custom_vocab_file.name
+        }
+    if use_custom_model and custom_model_url:
+        download_dir = os.path.join(".", "Working_files", "custom_model")
+        download_and_extract_zip(custom_model_url, download_dir)
+        custom_model = {
+            'model': os.path.join(download_dir, 'model.pth'),
+            'config': os.path.join(download_dir, 'config.json'),
+            'vocab': os.path.join(download_dir, 'vocab.json_')
+        }
+
+    # Add request to the queue
+    queue_lock.acquire()
+    queue.put((ebook_file, target_voice, language, email, use_custom_model, custom_model))
+    position = queue.qsize()
+    queue_lock.release()
+    return f"Your request has been added to the queue. You are number {position} in line."
+
+# Gradio UI setup
+language_options = [
+    "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"
+]
+
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="blue",
+    neutral_hue="blue",
+    text_size=gr.themes.sizes.text_md,
+)
+
+with gr.Blocks(theme=theme) as demo:
+    gr.Markdown(
+    """
+    # eBook to Audiobook Converter
+    
+    Transform your eBooks into immersive audiobooks with optional custom TTS models.
+    """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            ebook_file = gr.File(label="eBook File")
+            target_voice_file = gr.File(label="Target Voice File (Optional)")
+            language = gr.Dropdown(label="Language", choices=language_options, value="en")
+            email = gr.Textbox(label="Email Address")
+        
+        with gr.Column(scale=3):
+            use_custom_model = gr.Checkbox(label="Use Custom Model")
+            custom_model_file = gr.File(label="Custom Model File (Optional)", visible=False)
+            custom_config_file = gr.File(label="Custom Config File (Optional)", visible=False)
+            custom_vocab_file = gr.File(label="Custom Vocab File (Optional)", visible=False)
+            custom_model_url = gr.Textbox(label="Custom Model Zip URL (Optional)", visible=False)
+
+    convert_btn = gr.Button("Convert to Audiobook", variant="primary")
+    queue_status = gr.Textbox(label="Queue Status")
+
+    convert_btn.click(
+        enqueue_request,
+        inputs=[ebook_file, target_voice_file, language, email, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file, custom_model_url],
+        outputs=[queue_status]
+    )
+
+    use_custom_model.change(
+        lambda x: [gr.update(visible=x)] * 4,
+        inputs=[use_custom_model],
+        outputs=[custom_model_file, custom_config_file, custom_vocab_file, custom_model_url]
+    )
+
+demo.launch(share=True)

legacy/install.bat

@@ -0,0 +1,18 @@
+@echo off
+:: Check for administrative privileges
+net session >nul 2>&1
+if %errorLevel% neq 0 (
+    echo This script requires administrator privileges.
+    echo Switching to administrator...
+
+    powershell -Command "Start-Process cmd -ArgumentList '/c', '%~dpnx0' -Verb runAs"
+    exit /b
+)
+
+:: If already elevated, continue the script
+echo Running with administrator privileges...
+
+:: Run the PowerShell script in the same directory as this batch file
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0install.ps1"
+
+pause

legacy/install.ps1

@@ -0,0 +1,255 @@
+# Function to check if the script is running as Administrator
+function Test-IsAdmin {
+	$currentUser = New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())
+	return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+}
+
+# If the script is not running as Administrator, restart it with elevated privileges
+if (-not (Test-IsAdmin)) {
+	Write-Host "This script requires administrative privileges. Restarting as Administrator..." -ForegroundColor Yellow
+	Start-Process powershell.exe -ArgumentList "-NoProfile", "-ExecutionPolicy RemoteSigned", "-File", "`"$PSCommandPath`" $Params" -Verb RunAs
+	exit
+}
+
+################# Main script starts here with admin privileges #################
+
+# Function to check if Conda is installed
+function Check-CondaInstalled {
+	Write-Host "Checking if Conda is installed..."
+	$condaPath = (Get-Command conda -ErrorAction SilentlyContinue).Source
+	if ($condaPath) {
+		Write-Host "Conda is already installed at: $condaPath"
+		return $true
+	} else {
+		Write-Host "Conda is not installed."
+		return $false
+	}
+}
+
+function Check-ProgramsInstalled {
+	param (
+		[string[]]$Programs
+	)
+
+	$programsMissing = @()
+
+	if (-not (Get-Command choco -ErrorAction SilentlyContinue)) {
+		Write-Host "Chocolatey is not installed. Installing Chocolatey..."
+		Set-ExecutionPolicy Bypass -Scope Process -Force
+		[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+		iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+
+		if (-not (Get-Command choco -ErrorAction SilentlyContinue)) {
+			return $true
+		} else {
+			Write-Host "Chocolatey installed successfully."
+		}
+	}
+
+	foreach ($program in $Programs) {
+		if (Get-Command $program -ErrorAction SilentlyContinue) {
+			Write-Host "$program is installed."
+		} else {
+			$programsMissing += $program
+		}
+	}
+
+	$missingCount = $programsMissing.Count
+
+	if ($missingCount -eq 0) {
+		return $true
+	} else {
+		$installedCount = 0
+		foreach ($program in $programsMissing) {
+			if ($program -eq "ffmpeg") {
+				Write-Host "Installing ffmpeg..."
+				choco install ffmpeg -y
+
+				if (Get-Command ffmpeg -ErrorAction SilentlyContinue) {
+					Write-Host "ffmpeg installed successfully!"
+					$installedCount += 1
+				}
+			} elseif ($program -eq "calibre") {
+				# Avoid conflict with calibre built-in lxml
+				pip uninstall lxml -y
+
+				# Install Calibre using Chocolatey
+				Write-Host "Installing Calibre..."
+				choco install calibre -y
+
+				# Verify Calibre installation
+				if (Get-Command calibre -ErrorAction SilentlyContinue) {
+						Write-Host "Calibre installed successfully!"
+					$installedCount += 1
+				}
+			}
+		}
+	}
+	if ($installedCount -eq $countMissing) {
+		return $false
+	}
+	return $true
+}
+
+# Function to check if Docker is installed and running
+function Check-Docker {
+	Write-Host "Checking if Docker is installed..."
+	$dockerPath = (Get-Command docker -ErrorAction SilentlyContinue).Source
+	if ($dockerPath) {
+		Write-Host "Docker is installed at: $dockerPath"
+		# Check if Docker service is running
+		$dockerStatus = (Get-Service -Name com.docker.service -ErrorAction SilentlyContinue).Status
+		if ($dockerStatus -eq 'Running') {
+			Write-Host "Docker service is running."
+			return $true
+		} else {
+			Write-Host "Docker service is installed but not running. Attempting to start Docker service..."
+			Start-Service -Name "com.docker.service" -ErrorAction SilentlyContinue
+
+			# Wait for Docker service to start
+			while ((Get-Service -Name "com.docker.service").Status -ne 'Running') {
+				Write-Host "Waiting for Docker service to start..."
+				Start-Sleep -Seconds 5
+			}
+			Write-Host "Docker service is now running."
+			return $true
+		}
+	} else {
+		Write-Host "Docker is not installed."
+		return $false
+	}
+}
+
+######### Miniconda installation
+
+$minicondaUrl = "https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe"
+$installerPath = "$env:TEMP\Miniconda3-latest-Windows-x86_64.exe"
+
+if (-not (Check-CondaInstalled)) {
+	# Check if the Miniconda installer already exists
+	if (-not (Test-Path $installerPath)) {
+		Write-Host "Downloading Miniconda installer..."
+		Invoke-WebRequest -Uri $minicondaUrl -OutFile $installerPath
+	} else {
+		Write-Host "Miniconda installer already exists at $installerPath. Skipping download."
+	}
+
+	# Set the installation path for Miniconda
+	$installPath = "C:\Miniconda3"
+
+	Write-Host "Installing Miniconda..."
+	Start-Process -FilePath $installerPath -ArgumentList "/InstallationType=JustMe", "/RegisterPython=0", "/AddToPath=1", "/S", "/D=$installPath" -NoNewWindow -Wait
+
+	Write-Host "Verifying Miniconda installation..."
+	& "$installPath\Scripts\conda.exe" --version
+	Write-Host "Miniconda installation complete."
+} else {
+	Write-Host "Skipping Miniconda installation."
+}
+
+######### Docker installation
+
+$dockerMsiUrl = "https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe"
+$dockerInstallerPath = "$env:TEMP\DockerInstaller.exe"
+
+$dockerUtilsNeeded = Check-ProgramsInstalled -Programs @("ffmpeg", "calibre")
+
+if ($dockerUtilsNeeded) {
+	if (-not (Check-Docker)) {
+		# Verify the installer file or re-download if corrupted or missing
+		if (-not (Test-Path $dockerInstallerPath)) {
+			Write-Host "Downloading Docker installer for Windows..."
+			Invoke-WebRequest -Uri $dockerMsiUrl -OutFile $dockerInstallerPath
+		}
+
+		# Launch the Docker installer
+		Write-Host "Launching Docker installer..."
+		Start-Process -FilePath $dockerInstallerPath
+		Write-Host "Please complete the Docker installation manually."
+		pause
+
+		# Ensure Docker service is running after installation
+		Write-Host "Ensuring Docker service is running..."
+		Start-Service -Name "com.docker.service" -ErrorAction SilentlyContinue
+
+		# Wait for Docker service to start
+		while ((Get-Service -Name "com.docker.service").Status -ne 'Running') {
+			Write-Host "Waiting for Docker service to start..."
+			Start-Sleep -Seconds 5
+		}
+
+		Write-Host "Docker service is now running."
+	}
+}
+
+######### Install ebook2audiobook
+
+if (Check-CondaInstalled) {
+
+	Write-Host "Installing ebook2audiobook..." -ForegroundColor Yellow
+
+	# Set the working directory to the script's directory
+	$scriptDir = $PSScriptRoot
+	Set-Location -Path $scriptDir
+
+	# Create new Conda environment with Python 3.11 in the script directory, showing progress
+	Write-Host "Creating Conda environment with Python 3.11 in $scriptDir..."
+	& conda create --prefix "$scriptDir\python_env" python=3.11 -y -v
+
+	# Ensure the correct Python environment is active
+	Write-Host "Checking Python version in Conda environment..."
+
+	# Get python.exe version from python_env
+	$pythonEnvVersion = & "$scriptDir\python_env\python.exe" --version
+
+	# Get the Conda-managed Python version using conda run
+	$pythonVersion = & conda run --prefix "$scriptDir\python_env" python --version
+	
+	if ($pythonVersion.Trim() -eq $pythonEnvVersion.Trim()) {
+		Write-Host "Python versions match, proceeding with installation..."
+
+		if ($dockerUtilsNeeded) {
+			# Build Docker image for utils
+			Write-Host "Building Docker image for utils..."
+			& conda run --prefix "$scriptDir\python_env" docker build -f DockerfileUtils -t utils .
+		}
+
+		# Install required Python packages with pip, showing progress
+		Write-Host "Installing required Python packages..."
+		& conda run --prefix "$scriptDir\python_env" python.exe -m pip install --upgrade pip --progress-bar on -v
+		& conda run --prefix "$scriptDir\python_env" pip install pydub nltk beautifulsoup4 ebooklib translate coqui-tts tqdm mecab mecab-python3 unidic gradio>=4.44.0 docker --progress-bar on -v
+
+		# Download unidic language model for MeCab with progress
+		Write-Host "Downloading unidic language model for MeCab..."
+		& conda run --prefix "$scriptDir\python_env" python.exe -m unidic download
+
+		# Download spacy NLP model with progress
+		Write-Host "Downloading spaCy language model..."
+		& conda run --prefix "$scriptDir\python_env" python.exe -m spacy download en_core_web_sm
+
+		# Install ebook2audiobook
+		Write-Host "Installing ebook2audiobook..."
+		& conda run --prefix "$scriptDir\python_env" pip install -e .
+
+		# Delete Docker and Miniconda installers if both are installed and running
+		if ((Check-CondaInstalled) -and (Check-Docker)) {
+			Write-Host "Both Conda and Docker are installed and running. Deleting installer files..."
+			Remove-Item -Path $installerPath -Force -ErrorAction SilentlyContinue
+			Remove-Item -Path $dockerInstallerPath -Force -ErrorAction SilentlyContinue
+			Write-Host "Installer files deleted."
+		}
+
+		Write-Host "******************* ebook2audiobook installation successful! *******************" -ForegroundColor Green
+		Write-Host "To launch ebook2audiobook:" -ForegroundColor Yellow
+		Write-Host "- in command line mode: ./ebook2audiobook.cmd --headless [other options]"
+		Write-Host "- in graphic web mode: ./ebook2audiobook.cmd [--share]"
+	} else {
+		Write-Host "The python terminal is still using the OS python version $pythonVersion, but it should be $pythonEnvVersion from the python_env virtual environment"
+	}
+	
+	# Deactivate Conda environment
+	Write-Host "Deactivating Conda environment..."
+	& conda deactivate
+} else {
+	Write-Host "Installation cannot proceed. Either Conda is not installed or Docker is not running." -ForegroundColor Red
+}

legacy/install.sh

@@ -0,0 +1,171 @@
+#!/usr/bin/env bash
+
+WGET=$(which wget 2>/dev/null)
+CONDA_VERSION=$(conda --version 2>/dev/null)
+DOCKER_UTILS=$(which docker 2>/dev/null)
+DOCKER_UTILS_NEEDED=false
+PACK_MGR=""
+PACK_MGR_OPTIONS=""
+
+if [[ "$OSTYPE" == "darwin"* ]]; then
+	PACK_MGR="brew install"
+elif command -v emerge &> /dev/null; then
+	PACK_MGR="sudo emerge"
+elif command -v dnf &> /dev/null; then
+	PACK_MGR="sudo dnf install"
+	PACK_MGR_OPTIONS="-y"
+elif command -v yum &> /dev/null; then
+	PACK_MGR="sudo yum install"
+	PACK_MGR_OPTIONS="-y"
+elif command -v zypper &> /dev/null; then
+	PACK_MGR="sudo zypper install"
+	PACK_MGR_OPTIONS="-y"
+elif command -v pacman &> /dev/null; then
+	PACK_MGR="sudo pacman -Sy"
+elif command -v apt-get &> /dev/null; then
+	sudo apt-get update
+	PACK_MGR="sudo apt-get install"
+	PACK_MGR_OPTIONS="-y"
+elif command -v apk &> /dev/null; then
+	PACK_MGR="sudo apk add"
+fi
+
+check_programs_installed() {
+	local programs=("$@")
+	declare -a programs_missing
+	
+	for program in "${programs[@]}"; do
+		if command -v "$program" >/dev/null 2>&1; then
+			echo "$program is installed."
+		else
+			echo "$program is not installed."
+			programs_missing+=($program)
+		fi
+	done
+	
+	local count=${#programs_missing[@]}
+	
+	if [[ $count -eq 0 || "$PKG_MGR" = "" ]]; then
+		DOCKER_UTILS_NEEDED=true
+	else
+		for program in "${programs_missing[@]}"; do
+			if [ "$program" = "ffmpeg" ];then
+				eval "$PKG_MGR ffmpeg $PKG_MGR_OPTIONS"				
+				if command -v ffmpeg >/dev/null 2>&1; then
+					echo "FFmpeg installed successfully!"
+				else
+					echo "FFmpeg installation failed."
+					DOCKER_UTILS_NEEDED=true
+					break
+				fi
+			elif [ "$program" = "calibre" ];then				
+				# avoid conflict with calibre builtin lxml
+				pip uninstall lxml -y 2>/dev/null
+				
+				if [[ "$OSTYPE" == "Linux" ]]; then
+					echo "Installing Calibre for Linux..."
+					$WGET -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sh /dev/stdin
+				elif [[ "$OSTYPE" == "Darwin"* ]]; then
+					echo "Installing Calibre for macOS using Homebrew..."
+					eval "$PACK_MGR --cask calibre"
+				fi
+
+				if command -v calibre >/dev/null 2>&1; then
+					echo "Calibre installed successfully!"
+				else
+					echo "Calibre installation failed."
+				fi
+			fi
+		done
+	fi
+}
+
+# Check for Homebrew on macOS
+if [[ "$OSTYPE" == "darwin"* ]]; then
+	echo "Detected macOS."
+	if ! command -v brew &> /dev/null; then
+		echo "Homebrew is not installed. Installing Homebrew..."
+		/usr/bin/env bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+		echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
+		eval "$(/opt/homebrew/bin/brew shellenv)"
+	fi
+fi
+
+if [ -z "$WGET" ]; then
+	echo -e "\e[33m wget is missing! trying to install it... \e[0m"
+	if [ "$PACK_MGR" != "" ]; then
+		eval "$PACK_MGR wget $PACK_MGR_OPTIONS"
+	else
+		echo "Cannot recognize your package manager. Please install wget manually."
+	fi
+	WGET=$(which wget 2>/dev/null)
+fi
+
+if [[ -n "$WGET" && -z "$CONDA_VERSION" ]]; then
+	echo -e "\e[33m conda is missing! trying to install it... \e[0m"
+	
+	if [[ "$OSTYPE" == "darwin"* ]]; then
+		$WGET https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O Miniconda3-latest.sh
+	else
+		$WGET https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O Miniconda3-latest.sh
+	fi
+
+	chmod +x Miniconda3-latest.sh
+	./Miniconda3-latest.sh -b -u && \
+	~/miniconda3/bin/conda init && \
+	rm -f Miniconda3-latest.sh
+
+	# Source the appropriate shell configuration file
+	SHELL_RC=~/miniconda3/etc/profile.d/conda.sh
+	source $SHELL_RC
+
+	CONDA_VERSION=$(conda --version 2>/dev/null)
+	echo -e "\e[32m===============>>> conda is installed! <<===============\e[0m"
+fi
+
+check_programs_installed()
+
+if [ $DOCKER_UTILS_NEEDED = true ]; then
+	if [[ -n "$WGET" && -z "$DOCKER_UTILS" ]]; then
+		echo -e "\e[33m docker is missing! trying to install it... \e[0m"
+		if [[ "$OSTYPE" == "darwin"* ]]; then
+			echo "Installing Docker using Homebrew..."
+			brew install --cask docker
+		else
+			$WGET -qO get-docker.sh https://get.docker.com && \
+			sudo sh get-docker.sh && \
+			sudo systemctl start docker && \
+			sudo systemctl enable docker && \
+			docker run hello-world && \
+			DOCKER_UTILS=$(which docker 2>/dev/null)
+			rm -f get-docker.sh
+		fi
+		echo -e "\e[32m===============>>> docker is installed! <<===============\e[0m"
+	fi
+fi
+
+if [[ -n "$WGET" && -n "$CONDA_VERSION" ]]; then
+	SHELL_RC=~/miniconda3/etc/profile.d/conda.sh
+	echo -e "\e[33m Installing ebook2audiobook... \e[0m"
+	if [ $DOCKER_UTILS_NEEDED = true ]; then
+		conda create --prefix $(pwd)/python_env python=3.11 -y
+		source $SHELL_RC
+		conda activate $(pwd)/python_env
+		$DOCKER_UTILS build -f DockerfileUtils -t utils .
+	fi
+	pip install --upgrade pip && \
+	pip install pydub nltk beautifulsoup4 ebooklib translate coqui-tts tqdm mecab mecab-python3 unidic gradio>=4.44.0 docker && \
+	python -m unidic download && \
+	python -m spacy download en_core_web_sm && \
+	pip install -e .
+	if [ $DOCKER_UTILS_NEEDED = true ]; then
+		conda deactivate
+		conda deactivate
+	fi
+	echo -e "\e[32m******************* ebook2audiobook installation successful! *******************\e[0m"
+	echo -e "\e[33mTo launch ebook2audiobook:\e[0m"
+	echo -e "- in command line mode: ./ebook2audiobook.sh --headless [other options]"
+	echo -e "- in graphic web mode: ./ebook2audiobook.sh [--share]"
+fi
+
+exit 0