Upload 22 files

Notebooks/Kaggel Archive Code/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Drew Thomasson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Notebooks/Kaggel Archive Code/README.md

@@ -0,0 +1,118 @@
+# this is a sample for running on kaggle and it may not be updated frequently
+
+# ebook2audiobook kaggle eddition
+Generates an audiobook with chapters and ebook metadata using Calibre and Xtts from Coqui tts, and with optional voice cloning, and supports multiple languages
+
+# import this notebook to kaggle
+https://github.com/Rihcus/ebook2audiobookXTTS/blob/main/kaggle-ebook2audiobook-demo.ipynb
+
+## Features
+
+- Converts eBooks to text format using Calibre's `ebook-convert` tool.
+- Splits the eBook into chapters for structured audio conversion.
+- Uses XTTS from Coqui TTS for high-quality text-to-speech conversion.
+- Optional voice cloning feature using a provided voice file.
+- Supports different languages for text-to-speech conversion, with English as the default.
+- Confirmed to run on only 4 gb ram
+
+## Requirements
+
+- Python 3.x
+- `coqui-tts` Python package
+- Calibre (for eBook conversion)
+- FFmpeg (for audiobook file creation)
+- Optional: Custom voice file for voice cloning
+
+### Installation Instructions for Dependencies
+
+Install Python 3.x from [Python.org](https://www.python.org/downloads/).
+
+Install Calibre:
+- Ubuntu: `sudo apt-get install -y calibre`
+- macOS: `brew install calibre`
+- Windows(Powershell in Administrator mode): `choco install calibre` 
+
+Install FFmpeg:
+- Ubuntu: `sudo apt-get install -y ffmpeg`
+- macOS: `brew install ffmpeg`
+- Windows(Powershell in Administrator mode): `choco install ffmpeg` 
+
+Install Mecab for (Non Latin-based Languages tts support)(Optional):
+- Ubuntu: `sudo apt-get install -y mecab libmecab-dev mecab-ipadic-utf8`
+- macOS: `brew install mecab`, `brew install mecab-ipadic`
+- Windows(Powershell in Administrator mode no support for mecab-ipadic easy install so no Japanese for windows :/): `choco install mecab ` 
+
+Install Python packages:
+```bash
+pip install tts pydub nltk beautifulsoup4 ebooklib tqdm
+```
+(For non Latin-based Languages tts support)(Optional)  
+`python -m unidic download`
+```bash
+pip install mecab mecab-python3 unidic
+```
+
+### Supported Languages
+
+The script supports the following languages for text-to-speech conversion:
+
+English (en),
+Spanish (es),
+French (fr),
+German (de),
+Italian (it),
+Portuguese (pt),
+Polish (pl),
+Turkish (tr),
+Russian (ru),
+Dutch (nl),
+Czech (cs),
+Arabic (ar),
+Chinese (zh-cn),
+Japanese (ja),
+Hungarian (hu),
+Korean (ko)
+
+Specify the language code when running the script to use these languages.
+
+### Usage
+
+Navigate to the script's directory in the terminal and execute one of the following commands:
+If you have any trouble getting it to run in Windows then it should run fine in WSL2
+
+Basic Usage: ALL PARAMETERS ARE MANDATORY WHEN CALLED THE SCRIPT
+
+```bash
+python ebook2audiobook.py <path_to_ebook_file> [path_to_voice_file] [language_code]
+```
+Replace <path_to_ebook_file> with the path to your eBook file.
+include <path_to_voice_file> for voice cloning.
+include <language_code> to specify the language
+
+
+## Demo
+
+
+
+https://github.com/DrewThomasson/ebook2audiobookXTTS/assets/126999465/bccd7240-f967-4d27-a87d-445034db7d21
+
+
+
+### Supported ebook File Types: 
+.epub, .pdf, .mobi, .txt, .html, .rtf, .chm, .lit, .pdb, .fb2, .odt, .cbr, .cbz, .prc, .lrf, .pml, .snb, .cbc, .rb, and .tcr,
+(Best results are from using epub or mobi for auto chapter detection)
+
+### outputs as a m4b with all book metadata and chapters, example output file in an audiobook player app
+![Example_of_output_in_audiobook_program](https://github.com/DrewThomasson/VoxNovel/blob/dc5197dff97252fa44c391dc0596902d71278a88/readme_files/example_in_app.jpeg)
+
+A special thanks to the creaters of:
+
+
+-Coqui TTS
+
+-https://github.com/coqui-ai/TTS
+
+
+-Calibre
+
+-https://calibre-ebook.com

Notebooks/Kaggel Archive Code/Worker_2T4.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+workers=$1
+
+# Clean up operator directory
+rm -rf "./Operator"
+rm -rf "./Chapter_wav_files"
+mkdir "./Operator"
+mkdir "./Chapter_wav_files"
+
+
+# Make appropriate temp directories
+for i in $(seq 1 $workers); do
+    mkdir "./Operator/$i"
+    mkdir "./Operator/$i/temp"
+    mkdir "./Operator/$i/temp_ebook"
+done
+
+echo "Created $workers directories"
+
+#Divide the chapters
+share=1
+for FILE in ./Working_files/temp_ebook/*; do
+    cp $FILE "./Operator/$share/temp_ebook/"
+    if [ $share -lt $workers ];
+    then
+        share=$((share+1))
+    else
+        share=1
+    fi
+done
+
+echo "Split chapters into operator"
+
+#Run audio generation
+#for i in $(seq 1 $workers); do
+#    echo "Starting Worker $i"
+#    python p2a_worker.py $i &
+#done
+
+gpu=1
+for i in $(seq 1 $workers); do
+    if [ $gpu -lt 2 ];
+    then
+        echo "Starting Worker $i on GPU 1"
+        python p2a_worker_gpu1.py $i & #Run audio generation GPU 1 T4
+        gpu=2 # switch to gpu 2 on next loop
+    else
+        echo "Starting Worker $i on GPU 2"
+        python p2a_worker_gpu2.py $i & #Run audio generation GPU 2 T4
+        gpu=1 # switch to gpu 1 on next loop
+    fi
+done
+
+
+
+echo "All workers started waiting for completion...."
+wait
+echo "Done!"

Notebooks/Kaggel Archive Code/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)

Notebooks/Kaggel Archive Code/kaggle-ebook2audiobook-demo.ipynb

@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[],"dockerImageVersionId":30733,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"Install depdenencies","metadata":{}},{"cell_type":"code","source":"#!DEBIAN_FRONTEND=noninteractive\n!sudo apt-get update # && sudo apt-get -y upgrade\n!sudo apt-get -y install libegl1 \n!sudo apt-get -y install libopengl0\n!sudo apt-get -y install libxcb-cursor0\n!sudo -v && wget -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sudo sh /dev/stdin\n!sudo apt-get install -y ffmpeg\n!pip install tts pydub nltk beautifulsoup4 ebooklib tqdm\n!pip install numpy==1.26.4","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-06-17T21:17:43.474429Z","iopub.execute_input":"2024-06-17T21:17:43.474679Z","iopub.status.idle":"2024-06-17T21:20:20.992799Z","shell.execute_reply.started":"2024-06-17T21:17:43.474655Z","shell.execute_reply":"2024-06-17T21:20:20.991791Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Download modified ebook2audiobookXTTS\nhttps://github.com/Rihcus/ebook2audiobookXTTS\n\nOrigional unmodified version\nhttps://github.com/DrewThomasson/ebook2audiobookXTTS","metadata":{}},{"cell_type":"code","source":"!git clone https://github.com/Rihcus/ebook2audiobookXTTS","metadata":{"execution":{"iopub.status.busy":"2024-03-25T23:22:24.156772Z","iopub.execute_input":"2024-03-25T23:22:24.157618Z","iopub.status.idle":"2024-03-25T23:22:26.202486Z","shell.execute_reply.started":"2024-03-25T23:22:24.157577Z","shell.execute_reply":"2024-03-25T23:22:26.201179Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"(optional) Uploading your own epub book.\n\nBy default this notebook will use a sample epub book for testing/demo. \n\nIf you want to use your own book you will need to create a private kaggle data set, upload your epub to it, attach it to this notebook, and uncomment the two lines of code bellow, and update the data set path","metadata":{}},{"cell_type":"code","source":"# !cp -r /kaggle/input/<name of your attached dataset>/*.epub /kaggle/working/ebook2audiobookXTTS #copy your custom book\n# !rm /kaggle/working/ebook2audiobookXTTS/demo_mini_story_chapters_Drew.epub #remove default sample book","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This to install xtts_v2 models","metadata":{}},{"cell_type":"code","source":"import os\nos.environ[\"COQUI_TOS_AGREED\"] = \"1\"\n\n!cd /kaggle/working/ebook2audiobookXTTS && tts --model_name tts_models/multilingual/multi-dataset/xtts_v2 --text \"test\" --speaker_wav ./4.wav --language_idx en --use_cuda true","metadata":{"execution":{"iopub.status.busy":"2024-03-25T23:23:15.626677Z","iopub.execute_input":"2024-03-25T23:23:15.627585Z","iopub.status.idle":"2024-03-25T23:27:40.712856Z","shell.execute_reply.started":"2024-03-25T23:23:15.627548Z","shell.execute_reply":"2024-03-25T23:27:40.711852Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This is a modified version of ebook2audiobookXTTS. \n\n- p1.py only runs the first part ebook2audiobookXTTS and generates chapter txts (I commented out other parts)\n    - https://github.com/Rihcus/ebook2audiobookXTTS/blob/main/p1.py\n- Worker_2T4.sh as a basic attempt at multigpu support. The 4 argument processes of ebook2audiobook will be run in parallel\n    - Worker_2T4 will try to divide the chapter in even groups based on number of workers (ex 4 group 4 workers)\n    - It will try to divy up the work between kaggles two T4 GPUS\n    - I'm not sure how much of a difference it makes since kaggles cpu limitations\n    \nhttps://github.com/Rihcus/ebook2audiobookXTTS/blob/main/Worker_2T4.sh\n\nhttps://github.com/Rihcus/ebook2audiobookXTTS/blob/main/p2a_worker_gpu1.py\n\nhttps://github.com/Rihcus/ebook2audiobookXTTS/blob/main/p2a_worker_gpu2.py","metadata":{}},{"cell_type":"code","source":"!cd /kaggle/working/ebook2audiobookXTTS && python p1.py \"$(ls ./*.epub)\" \"4.wav\" \"en\"\n!cd /kaggle/working/ebook2audiobookXTTS && bash Worker_2T4.sh 4","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"p3.py runs the final ffmpeg command. ffmpeg has been a bit buggy\nhttps://github.com/Rihcus/ebook2audiobookXTTS/blob/main/p3.py","metadata":{}},{"cell_type":"code","source":"!cd /kaggle/working/ebook2audiobookXTTS && python p3.py \"$(ls ./*.epub)\" \"4.wav\" \"en\"","metadata":{},"execution_count":null,"outputs":[]}]}

Notebooks/Kaggel Archive Code/p1.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)

Notebooks/Kaggel Archive Code/p2a_worker_gpu1.py

@@ -0,0 +1,465 @@
+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 # not sure if this is needed
+
+# 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:0" 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")
+            temp_audio_directory = os.path.join(".", "Operator",worker_num, "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)
+
+    worker_num = sys.argv[1] #to let the script know which temp dir its using in operator
+#    ebook_file_path = sys.argv[1]
+    target_voice = "./4.wav" # sys.argv[2] if len(sys.argv) > 2 else None
+    language = "en" # 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")
+    chapters_directory = os.path.join(".","Operator",worker_num, "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)

Notebooks/Kaggel Archive Code/p2a_worker_gpu2.py

@@ -0,0 +1,465 @@
+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 # not sure if this is needed
+
+# 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:1" 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")
+            temp_audio_directory = os.path.join(".", "Operator",worker_num, "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)
+
+    worker_num = sys.argv[1] #to let the script know which temp dir its using in operator
+#    ebook_file_path = sys.argv[1]
+    target_voice = "./4.wav" # sys.argv[2] if len(sys.argv) > 2 else None
+    language = "en" # 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")
+    chapters_directory = os.path.join(".","Operator",worker_num, "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)

Notebooks/Kaggel Archive Code/p3.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)

Notebooks/colab_ebook2audiobookxtts.ipynb

@@ -0,0 +1,105 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/DrewThomasson/ebook2audiobookXTTS/blob/main/Notebooks/colab_ebook2audiobookxtts.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Welcome to the ebook2audiobookxtts free google colab!\n",
+        "## 🌟 Features\n",
+        "\n",
+        "- 📖 Converts eBooks to text format with Calibre.\n",
+        "- 📚 Splits eBook into chapters for organized audio.\n",
+        "- 🎙️ High-quality text-to-speech with Coqui XTTS.\n",
+        "- 🗣️ Optional voice cloning with your own voice file.\n",
+        "- 🌍 Supports multiple languages! (English (en), Spanish (es), French (fr), German (de), Italian (it), Portuguese (pt), Polish (pl), Turkish (tr), Russian (ru), Dutch (nl), Czech (cs), Arabic (ar), Chinese (zh-cn), Japanese (ja), Hungarian (hu), Korean (ko)).\n",
+        "## Want to run locally for free? ⬇\n",
+        "## [Check out the ebook2audiobookxtts github!](https://github.com/DrewThomasson/ebook2audiobookXTTS)"
+      ],
+      "metadata": {
+        "id": "DKNNnwD-HJwQ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title 🛠️ Install requirments\n",
+        "#!DEBIAN_FRONTEND=noninteractive\n",
+        "!sudo apt-get update # && sudo apt-get -y upgrade\n",
+        "!sudo apt-get -y install libegl1\n",
+        "!sudo apt-get -y install libopengl0\n",
+        "!sudo apt-get -y install libxcb-cursor0\n",
+        "!sudo -v && wget -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sudo sh /dev/stdin\n",
+        "!sudo apt-get install -y ffmpeg\n",
+        "#!sudo apt-get install -y calibre\n",
+        "!pip install ebook2audiobook-install-counter\n",
+        "!pip install ebooklib\n",
+        "!pip install pydub\n",
+        "!pip install nltk\n",
+        "!pip install beautifulsoup4\n",
+        "!pip install tqdm\n",
+        "!pip install gradio\n",
+        "!pip install coqui-tts"
+      ],
+      "metadata": {
+        "id": "Edxj355K0rUz",
+        "collapsed": true,
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title 🚀 Run ebook2audiobookxtts! (Make sure to set the runtime to have gpu to have faster generation speeds! :)\n",
+        "#ntlk error fix\n",
+        "#https://github.com/delip/PyTorchNLPBook/issues/14\n",
+        "import nltk\n",
+        "nltk.download('punkt')\n",
+        "\n",
+        "#Auto agree to xtts\n",
+        "import os\n",
+        "os.environ[\"COQUI_TOS_AGREED\"] = \"1\"\n",
+        "\n",
+        "# To download the app.py and the Default_voice wav if not seen locally\n",
+        "!wget -O /content/app.py https://raw.githubusercontent.com/DrewThomasson/ebook2audiobookXTTS/main/app.py\n",
+        "!wget -O /content/default_voice.wav https://raw.githubusercontent.com/DrewThomasson/ebook2audiobookXTTS/main/default_voice.wav\n",
+        "\n",
+        "# Start the app with Share=True for the gradio interface\n",
+        "!python /content/app.py --share True"
+      ],
+      "metadata": {
+        "id": "658BTHueyLMo",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Notebooks/kaggle-beta-of-ebook2audiobookxtts-ipynb.ipynb

@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"colab":{"provenance":[],"gpuType":"T4"},"accelerator":"GPU","kaggle":{"accelerator":"gpu","dataSources":[],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# IGNORE THESE ITS OLD LOL\n\n# install needed packages\n\n##!apt-get update\n\n##!apt-get install wget unzip git ffmpeg calibre\n\n\n\n# pip install requirments\n\n##!pip install tts==0.21.3 pydub nltk beautifulsoup4 ebooklib tqdm gradio\n\n\n\n##!pip install numpy==1.23\n\n##!pip install --no-binary lxml lxml\n\n##import os\n\n##os.kill(os.getpid(), 9)\n","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"gh3HEhmzuqVA","outputId":"81217d71-7576-43db-d56c-07ce11ea6517","jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#!DEBIAN_FRONTEND=noninteractive\n\n!sudo apt-get update # && sudo apt-get -y upgrade\n\n!sudo apt-get -y install libegl1\n\n!sudo apt-get -y install libopengl0\n\n!sudo apt-get -y install libxcb-cursor0\n\n!sudo -v && wget -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sudo sh /dev/stdin\n\n!sudo apt-get install -y ffmpeg\n\n!pip install tts pydub nltk beautifulsoup4 ebooklib tqdm\n\n!pip install numpy==1.26.4\n\n!pip install gradio","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"Edxj355K0rUz","outputId":"9fc5f4e1-1ba2-4814-a477-496f626c2772","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Start the app with Share=True for the gradio interface\n\n\n\n#ntlk error fix\n\n#https://github.com/delip/PyTorchNLPBook/issues/14\n\nimport nltk\n\nnltk.download('punkt')\n\n\n\n#Auto agree to xtts\n\nimport os\n\nos.environ[\"COQUI_TOS_AGREED\"] = \"1\"\n\n\n\n!python /kaggle/working/app.py --share True","metadata":{"id":"EZIZva9Tvdbb","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#ntlk error fix\n\n#https://github.com/delip/PyTorchNLPBook/issues/14\n\nimport nltk\n\nnltk.download('punkt')\n\n\n\n#Auto agree to xtts\n\nimport os\n\nos.environ[\"COQUI_TOS_AGREED\"] = \"1\"\n\n\n\n# To download the app.py and the Default_voice wav if not seen locally\n\n!wget -O /kaggle/working/app.py https://raw.githubusercontent.com/DrewThomasson/ebook2audiobookXTTS/main/app.py\n\n!wget -O /kaggle/working/default_voice.wav https://raw.githubusercontent.com/DrewThomasson/ebook2audiobookXTTS/main/default_voice.wav\n\n\n\n# Start the app with Share=True for the gradio interface\n\n!python /kaggle/working/app.py --share True","metadata":{"id":"658BTHueyLMo","colab":{"base_uri":"https://localhost:8080/"},"outputId":"e293e70d-b25a-41bc-dbac-7ca1ddf1d3d2","trusted":true},"execution_count":null,"outputs":[]}]}

lib/conf.py

@@ -0,0 +1,149 @@
+import os
+from lib.lang import default_voice_file
+
+NATIVE = 'native'
+DOCKER_UTILS = 'docker_utils'
+FULL_DOCKER = 'full_docker'
+
+version = '2.0.0'
+min_python_version = (3,10)
+max_python_version = (3,12)
+
+requirements_file = os.path.abspath(os.path.join('.','requirements.txt'))
+
+docker_utils_image = 'utils'
+
+interface_host = '0.0.0.0'
+interface_port = 7860
+interface_shared_expire = 72 # hours
+interface_concurrency_limit = 8 # or None for unlimited
+interface_component_options = {
+    "gr_tab_preferences": True,
+    "gr_voice_file": True,
+    "gr_group_custom_model": True
+}
+
+python_env_dir = os.path.abspath(os.path.join('.','python_env'))
+
+models_dir = os.path.abspath(os.path.join('.','models'))
+ebooks_dir = os.path.abspath(os.path.join('.','ebooks'))
+processes_dir = os.path.abspath(os.path.join('.','tmp'))
+
+audiobooks_gradio_dir = os.path.abspath(os.path.join('.','audiobooks','gui','gradio'))
+audiobooks_host_dir = os.path.abspath(os.path.join('.','audiobooks','gui','host'))
+audiobooks_cli_dir = os.path.abspath(os.path.join('.','audiobooks','cli'))
+
+# <<<<<<< HEAD
+# Automatically accept the non-commercial license
+os.environ['COQUI_TOS_AGREED'] = '1'
+os.environ['CALIBRE_TEMP_DIR'] = processes_dir
+os.environ['CALIBRE_CACHE_DIRECTORY'] = processes_dir
+os.environ['CALIBRE_NO_NATIVE_FILEDIALOGS'] = '1'
+os.environ['DO_NOT_TRACK'] = 'true'
+os.environ['HUGGINGFACE_HUB_CACHE'] = models_dir
+os.environ['TTS_HOME'] = models_dir
+os.environ['HF_HOME'] = models_dir
+os.environ['HF_DATASETS_CACHE'] = models_dir
+os.environ['HF_TOKEN_PATH'] = os.path.join(os.path.expanduser('~'), '.huggingface_token')
+os.environ['TTS_CACHE'] = models_dir
+os.environ['TORCH_HOME'] = models_dir
+os.environ['XDG_CACHE_HOME'] = models_dir
+
+ebook_formats = ['.epub', '.mobi', '.azw3', 'fb2', 'lrf', 'rb', 'snb', 'tcr', '.pdf', '.txt', '.rtf', 'doc', '.docx', '.html', '.odt', '.azw']
+audiobook_format = 'm4b' # or 'mp3'
+audioproc_format = 'wav' # only 'wav' is valid for now
+
+default_tts_engine = 'xtts'
+default_fine_tuned = 'std'
+default_model_files = ['config.json', 'vocab.json', 'model.pth', 'ref.wav']
+
+models = {
+    "xtts": {
+        "std": {
+            "lang": "multi",
+            "repo": "tts_models/multilingual/multi-dataset/xtts_v2",
+            "sub": "",
+            "voice": default_voice_file
+        },
+        "AiExplained": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/AiExplained",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "AiExplained_24khz.wav"))
+        },
+        "BobOdenkirk": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/BobOdenkirk",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "BobOdenkirk_24khz.wav"))
+        },
+        "BobRoss": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/BobRoss",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "BobRoss_24khz.wav"))
+        },
+        "BryanCranston": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/BryanCranston",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "BryanCranston_24khz.wav"))
+        },
+        "DavidAttenborough": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/DavidAttenborough",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "elder", "male", "DavidAttenborough_24khz.wav"))
+        },
+        "DeathPuss&Boots": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/DeathPuss&Boots",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "DeathPuss&Boots_24khz.wav"))
+        },
+        "GhostMW2": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/GhostMW2",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "GhostMW2_24khz.wav"))
+        },
+        "JhonButlerASMR": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/JhonButlerASMR",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "elder", "male", "JhonButlerASMR_24khz.wav"))
+        },
+        "JhonMulaney": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/JhonMulaney",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "JhonMulaney_24khz.wav"))
+        },
+        "MorganFreeman": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/MorganFreeman",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "MorganFreeman_24khz.wav"))
+        },
+        "RainyDayHeadSpace": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/RainyDayHeadSpace",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "elder", "male", "RainyDayHeadSpace_24khz.wav"))
+        },
+        "WhisperSalemASMR": {
+            "lang": "eng",
+            "repo": "drewThomasson/fineTunedTTSModels",
+            "sub": "xtts-v2/eng/WhisperSalemASMR",
+            "voice": os.path.abspath(os.path.join("voices", "eng", "adult", "male", "WhisperSalemASMR_24khz.wav"))
+        }
+    },
+    "fairseq": {
+        "std": {
+            "lang": "multi",
+            "repo": "tts_models/[lang]/fairseq/vits",
+            "sub": "",
+            "voice": default_voice_file
+        }
+    }
+}

lib/functions.py

@@ -0,0 +1,1594 @@
+import argparse
+import csv
+import docker
+import ebooklib
+import fnmatch
+import gradio as gr
+import hashlib
+import json
+import numpy as np
+import os
+import regex as re
+import requests
+import shutil
+import socket
+import subprocess
+import sys
+import threading
+import time
+import torch
+import torchaudio
+import urllib.request
+import uuid
+import zipfile
+import traceback
+
+from bs4 import BeautifulSoup
+from collections import Counter
+from collections.abc import MutableMapping
+from datetime import datetime
+from ebooklib import epub
+from glob import glob
+from huggingface_hub import hf_hub_download
+from iso639 import languages
+from multiprocessing import Manager, Event
+from pydub import AudioSegment
+from tqdm import tqdm
+from translate import Translator
+from TTS.api import TTS as XTTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from urllib.parse import urlparse
+
+import lib.conf as conf
+import lib.lang as lang
+
+def inject_configs(target_namespace):
+    # Extract variables from both modules and inject them into the target namespace
+    for module in (conf, lang):
+        target_namespace.update({k: v for k, v in vars(module).items() if not k.startswith('__')})
+
+# Inject configurations into the global namespace of this module
+inject_configs(globals())
+
+def recursive_proxy(data, manager=None):
+    """Recursively convert a nested dictionary into Manager.dict proxies."""
+    if manager is None:
+        manager = Manager()
+    if isinstance(data, dict):
+        proxy_dict = manager.dict()
+        for key, value in data.items():
+            proxy_dict[key] = recursive_proxy(value, manager)
+        return proxy_dict
+    elif isinstance(data, list):
+        proxy_list = manager.list()
+        for item in data:
+            proxy_list.append(recursive_proxy(item, manager))
+        return proxy_list
+    elif isinstance(data, (str, int, float, bool, type(None))):  # Scalars
+        return data
+    else:
+        raise TypeError(f"Unsupported data type: {type(data)}")
+
+class ConversionContext:
+    def __init__(self):
+        self.manager = Manager()
+        self.sessions = self.manager.dict()  # Store all session-specific contexts
+        self.cancellation_events = {}  # Store multiprocessing.Event for each session
+
+    def get_session(self, session_id):
+        """Retrieve or initialize session-specific context"""
+        if session_id not in self.sessions:
+            self.sessions[session_id] = recursive_proxy({
+                "script_mode": NATIVE,
+                "client": None,
+                "language": default_language_code,
+                "audiobooks_dir": None,
+                "tmp_dir": None,
+                "src": None,
+                "id": session_id,
+                "chapters_dir": None,
+                "chapters_dir_sentences": None,
+                "epub": None,
+                "epub_path": None,
+                "filename_noext": None,
+                "fine_tuned": None,
+                "voice_file": None,
+                "custom_model": None,
+                "custom_model_dir": None,
+                "chapters": None,
+                "cover": None,
+                "metadata": {
+                    "title": None, 
+                    "creator": None,
+                    "contributor": None,
+                    "language": None,
+                    "language_iso1": None,
+                    "identifier": None,
+                    "publisher": None,
+                    "date": None,
+                    "description": None,
+                    "subject": None,
+                    "rights": None,
+                    "format": None,
+                    "type": None,
+                    "coverage": None,
+                    "relation": None,
+                    "Source": None,
+                    "Modified": None,
+                },
+                "status": "Idle",
+                "progress": 0,
+                "cancellation_requested": False
+            }, manager=self.manager)
+        return self.sessions[session_id]
+        
+context = ConversionContext()
+is_gui_process = False
+
+class DependencyError(Exception):
+    def __init__(self, message=None):
+        super().__init__(message)
+        # Automatically handle the exception when it's raised
+        self.handle_exception()
+
+    def handle_exception(self):
+        # Print the full traceback of the exception
+        traceback.print_exc()
+        
+        # Print the exception message
+        print(f'Caught DependencyError: {self}')
+        
+        # Exit the script if it's not a web process
+        if not is_gui_process:
+            sys.exit(1)
+
+def prepare_dirs(src, session):
+    try:
+        resume = False
+        os.makedirs(os.path.join(models_dir,'tts'), exist_ok=True)
+        os.makedirs(session['tmp_dir'], exist_ok=True)
+        os.makedirs(session['custom_model_dir'], exist_ok=True)
+        os.makedirs(session['audiobooks_dir'], exist_ok=True)
+        session['src'] = os.path.join(session['tmp_dir'], os.path.basename(src))
+        if os.path.exists(session['src']):
+            if compare_files_by_hash(session['src'], src):
+                resume = True
+        if not resume:
+            shutil.rmtree(session['chapters_dir'], ignore_errors=True)
+        os.makedirs(session['chapters_dir'], exist_ok=True)
+        os.makedirs(session['chapters_dir_sentences'], exist_ok=True)
+        shutil.copy(src, session['src']) 
+        return True
+    except Exception as e:
+        raise DependencyError(e)
+
+def check_programs(prog_name, command, options):
+    try:
+        subprocess.run([command, options], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return True, None
+    except FileNotFoundError:
+        e = f'''********** Error: {prog_name} is not installed! if your OS calibre package version 
+        is not compatible you still can run ebook2audiobook.sh (linux/mac) or ebook2audiobook.cmd (windows) **********'''
+        raise DependencyError(e)
+    except subprocess.CalledProcessError:
+        e = f'Error: There was an issue running {prog_name}.'
+        raise DependencyError(e)
+        
+def check_fine_tuned(fine_tuned, language):
+    try:
+        for parent, children in models.items():
+            if fine_tuned in children:
+                if language_xtts.get(language):
+                    tts = 'xtts'
+                else:
+                    tts = 'fairseq'
+                if parent == tts:
+                    return parent
+        return False
+    except Exception as e:
+        raise RuntimeError(e)
+
+def analyze_uploaded_file(zip_path, required_files=None):
+    if required_files is None:
+        required_files = default_model_files
+    executable_extensions = {'.exe', '.bat', '.cmd', '.bash', '.bin', '.sh', '.msi', '.dll', '.com'}
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zf:
+            files_in_zip = set()
+            executables_found = False
+            for file_info in zf.infolist():
+                file_name = file_info.filename
+                if file_info.is_dir():
+                    continue  # Skip directories
+                base_name = os.path.basename(file_name)
+                files_in_zip.add(base_name)
+                _, ext = os.path.splitext(base_name.lower())
+                if ext in executable_extensions:
+                    executables_found = True
+                    break
+            missing_files = [f for f in required_files if f not in files_in_zip]
+            is_valid = not executables_found and not missing_files
+            return is_valid, 
+    except zipfile.BadZipFile:
+        raise ValueError("error: The file is not a valid ZIP archive.")
+    except Exception as e:
+        raise RuntimeError(f'analyze_uploaded_file(): {e}')
+
+async def extract_custom_model(file_src, dest=None, session=None, required_files=None):
+    try:
+        progress_bar = None
+        if is_gui_process:
+            progress_bar = gr.Progress(track_tqdm=True) 
+        if dest is None:
+            dest = session['custom_model_dir'] = os.path.join(models_dir, '__sessions', f"model-{session['id']}")
+            os.makedirs(dest, exist_ok=True)
+        if required_files is None:
+            required_files = default_model_files
+
+        dir_src = os.path.dirname(file_src)
+        dir_name = os.path.basename(file_src).replace('.zip', '')
+
+        with zipfile.ZipFile(file_src, 'r') as zip_ref:
+            files = zip_ref.namelist()
+            files_length = len(files)
+            dir_tts = 'fairseq'
+            xtts_config = 'config.json'
+
+            # Check the model type
+            config_data = {}
+            if xtts_config in zip_ref.namelist():
+                with zip_ref.open(xtts_config) as file:
+                    config_data = json.load(file)
+            if config_data.get('model') == 'xtts':
+                dir_tts = 'xtts'
+            
+            dir_dest = os.path.join(dest, dir_tts, dir_name)
+            os.makedirs(dir_dest, exist_ok=True)
+
+            # Initialize progress bar
+            with tqdm(total=100, unit='%') as t:  # Track progress as a percentage
+                for i, file in enumerate(files):
+                    if file in required_files:
+                        zip_ref.extract(file, dir_dest)
+                    progress_percentage = ((i + 1) / files_length) * 100
+                    t.n = int(progress_percentage)
+                    t.refresh()
+                    if progress_bar is not None:
+                        progress_bar(downloaded / total_size)
+                        yield dir_name, progress_bar
+
+        os.remove(file_src)
+        print(f'Extracted files to {dir_dest}')
+        yield dir_name, progress_bar
+        return
+    except Exception as e:
+        raise DependencyError(e)
+
+def calculate_hash(filepath, hash_algorithm='sha256'):
+    hash_func = hashlib.new(hash_algorithm)
+    with open(filepath, 'rb') as file:
+        while chunk := file.read(8192):  # Read in chunks to handle large files
+            hash_func.update(chunk)
+    return hash_func.hexdigest()
+
+def compare_files_by_hash(file1, file2, hash_algorithm='sha256'):
+    return calculate_hash(file1, hash_algorithm) == calculate_hash(file2, hash_algorithm)
+
+def has_metadata(f):
+    try:
+        b = epub.read_epub(f)
+        metadata = b.get_metadata('DC', '')
+        if metadata:
+            return True
+        else:
+            return False
+    except Exception as e:
+        return False
+
+def convert_to_epub(session):
+    if session['cancellation_requested']:
+        #stop_and_detach_tts()
+        print('Cancel requested')
+        return False
+    if session['script_mode'] == DOCKER_UTILS:
+        try:
+            docker_dir = os.path.basename(session['tmp_dir'])
+            docker_file_in = os.path.basename(session['src'])
+            docker_file_out = os.path.basename(session['epub_path'])
+            
+            # Check if the input file is already an EPUB
+            if docker_file_in.lower().endswith('.epub'):
+                shutil.copy(session['src'], session['epub_path'])
+                return True
+
+            # Convert the ebook to EPUB format using utils Docker image
+            container = session['client'].containers.run(
+                docker_utils_image,
+                command=f'ebook-convert /files/{docker_dir}/{docker_file_in} /files/{docker_dir}/{docker_file_out}',
+                volumes={session['tmp_dir']: {'bind': f'/files/{docker_dir}', 'mode': 'rw'}},
+                remove=True,
+                detach=False,
+                stdout=True,
+                stderr=True
+            )
+            print(container.decode('utf-8'))
+            return True
+        except docker.errors.ContainerError as e:
+            raise DependencyError(e)
+        except docker.errors.ImageNotFound as e:
+            raise DependencyError(e)
+        except docker.errors.APIError as e:
+            raise DependencyError(e)
+    else:
+        try:
+            util_app = shutil.which('ebook-convert')
+            subprocess.run([util_app, session['src'], session['epub_path']], check=True)
+            return True
+        except subprocess.CalledProcessError as e:
+            raise DependencyError(e)
+
+def get_cover(session):
+    try:
+        if session['cancellation_requested']:
+            #stop_and_detach_tts()
+            print('Cancel requested')
+            return False
+        cover_image = False
+        cover_path = os.path.join(session['tmp_dir'], session['filename_noext'] + '.jpg')
+        for item in session['epub'].get_items_of_type(ebooklib.ITEM_COVER):
+            cover_image = item.get_content()
+            break
+        if not cover_image:
+            for item in session['epub'].get_items_of_type(ebooklib.ITEM_IMAGE):
+                if 'cover' in item.file_name.lower() or 'cover' in item.get_id().lower():
+                    cover_image = item.get_content()
+                    break
+        if cover_image:
+            with open(cover_path, 'wb') as cover_file:
+                cover_file.write(cover_image)
+                return cover_path
+        return True
+    except Exception as e:
+        raise DependencyError(e)
+
+def get_chapters(language, session):
+    try:
+        if session['cancellation_requested']:
+            #stop_and_detach_tts()
+            print('Cancel requested')
+            return False
+        all_docs = list(session['epub'].get_items_of_type(ebooklib.ITEM_DOCUMENT))
+        if all_docs:
+            all_docs = all_docs[1:]
+            doc_patterns = [filter_pattern(str(doc)) for doc in all_docs if filter_pattern(str(doc))]
+            most_common_pattern = filter_doc(doc_patterns)
+            selected_docs = [doc for doc in all_docs if filter_pattern(str(doc)) == most_common_pattern]
+            chapters = [filter_chapter(doc, language) for doc in selected_docs]
+            if session['metadata'].get('creator'):
+                intro = f"{session['metadata']['creator']}, {session['metadata']['title']};\n "
+                chapters[0].insert(0, intro)
+            return chapters
+        return False
+    except Exception as e:
+        raise DependencyError(f'Error extracting main content pages: {e}')
+
+def filter_doc(doc_patterns):
+    pattern_counter = Counter(doc_patterns)
+    # Returns a list with one tuple: [(pattern, count)] 
+    most_common = pattern_counter.most_common(1)
+    return most_common[0][0] if most_common else None
+
+def filter_pattern(doc_identifier):
+    parts = doc_identifier.split(':')
+    if len(parts) > 2:
+        segment = parts[1]
+        if re.search(r'[a-zA-Z]', segment) and re.search(r'\d', segment):
+            return ''.join([char for char in segment if char.isalpha()])
+        elif re.match(r'^[a-zA-Z]+$', segment):
+            return segment
+        elif re.match(r'^\d+$', segment):
+            return 'numbers'
+    return None
+
+def filter_chapter(doc, language):
+    soup = BeautifulSoup(doc.get_body_content(), 'html.parser')
+    # Remove scripts and styles
+    for script in soup(["script", "style"]):
+        script.decompose()
+    # Normalize lines and remove unnecessary spaces
+    text = re.sub(r'(\r\n|\r|\n){3,}', '\r\n', soup.get_text().strip())
+    text = replace_roman_numbers(text)
+    lines = (line.strip() for line in text.splitlines())
+    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+    text = '\n'.join(chunk for chunk in chunks if chunk)
+    text = text.replace('»', '"').replace('«', '"')
+    # Pattern 1: Add a space between UTF-8 characters and numbers
+    text = re.sub(r'(?<=[\p{L}])(?=\d)|(?<=\d)(?=[\p{L}])', ' ', text)
+    # Pattern 2: Split numbers into groups of 4
+    text = re.sub(r'(\d{4})(?=\d)', r'\1 ', text)
+    chapter_sentences = get_sentences(text, language)
+    return chapter_sentences
+
+def get_sentences(sentence, language, max_pauses=9):
+    max_length = language_mapping[language]['char_limit']
+    punctuation = language_mapping[language]['punctuation']
+    sentence = sentence.replace(".", ";\n")
+    parts = []
+    while len(sentence) > max_length or sum(sentence.count(p) for p in punctuation) > max_pauses:
+        # Step 1: Look for the last period (.) within max_length
+        possible_splits = [i for i, char in enumerate(sentence[:max_length]) if char == '.']    
+        # Step 2: If no periods, look for the last comma (,)
+        if not possible_splits:
+            possible_splits = [i for i, char in enumerate(sentence[:max_length]) if char == ',']    
+        # Step 3: If still no splits, look for any other punctuation
+        if not possible_splits:
+            possible_splits = [i for i, char in enumerate(sentence[:max_length]) if char in punctuation]    
+        # Step 4: Determine where to split the sentence
+        if possible_splits:
+            split_at = possible_splits[-1] + 1  # Split at the last occurrence of punctuation
+        else:
+            # If no punctuation is found, split at the last space
+            last_space = sentence.rfind(' ', 0, max_length)
+            if last_space != -1:
+                split_at = last_space + 1
+            else:
+                # If no space is found, force split at max_length
+                split_at = max_length   
+        # Add the split sentence to parts
+        parts.append(sentence[:split_at].strip() + ' ')
+        sentence = sentence[split_at:].strip()
+    # Add the remaining sentence if any
+    if sentence:
+        parts.append(sentence.strip() + ' ')
+    return parts
+
+def convert_chapters_to_audio(session):
+    try:
+        if session['cancellation_requested']:
+            #stop_and_detach_tts()
+            print('Cancel requested')
+            return False
+        progress_bar = None
+        params = {}
+        if is_gui_process:
+            progress_bar = gr.Progress(track_tqdm=True)        
+        params['tts_model'] = None
+        '''
+        # List available TTS base models
+        print("Available Models:")
+        print("=================")
+        for index, model in enumerate(XTTS().list_models(), 1):
+            print(f"{index}. {model}")
+        '''
+        if session['metadata']['language'] in language_xtts:
+            params['tts_model'] = 'xtts'
+            if session['custom_model'] is not None:
+                print(f"Loading TTS {params['tts_model']} model from {session['custom_model']}...")
+                model_path = os.path.join(session['custom_model'], 'model.pth')
+                config_path = os.path.join(session['custom_model'],'config.json')
+                vocab_path = os.path.join(session['custom_model'],'vocab.json')
+                voice_path = os.path.join(session['custom_model'],'ref.wav')
+                config = XttsConfig()
+                config.models_dir = os.path.join(models_dir,'tts')
+                config.load_json(config_path)
+                params['tts'] = Xtts.init_from_config(config)
+                params['tts'].load_checkpoint(config, checkpoint_path=model_path, vocab_path=vocab_path, eval=True)
+                print('Computing speaker latents...')
+                params['voice_file'] = session['voice_file'] if session['voice_file'] is not None else voice_path
+                params['gpt_cond_latent'], params['speaker_embedding'] = params['tts'].get_conditioning_latents(audio_path=[params['voice_file']])
+            elif session['fine_tuned'] != 'std':
+                print(f"Loading TTS {params['tts_model']} model from {session['fine_tuned']}...")
+                hf_repo = models[params['tts_model']][session['fine_tuned']]['repo']
+                hf_sub = models[params['tts_model']][session['fine_tuned']]['sub']
+                cache_dir = os.path.join(models_dir,'tts')
+                model_path = hf_hub_download(repo_id=hf_repo, filename=f"{hf_sub}/model.pth", cache_dir=cache_dir)
+                config_path = hf_hub_download(repo_id=hf_repo, filename=f"{hf_sub}/config.json", cache_dir=cache_dir)
+                vocab_path = hf_hub_download(repo_id=hf_repo, filename=f"{hf_sub}/vocab.json", cache_dir=cache_dir)             
+                config = XttsConfig()
+                config.models_dir = cache_dir
+                config.load_json(config_path)
+                params['tts'] = Xtts.init_from_config(config)
+                params['tts'].load_checkpoint(config, checkpoint_path=model_path, vocab_path=vocab_path, eval=True)
+                print('Computing speaker latents...')
+                params['voice_file'] = session['voice_file'] if session['voice_file'] is not None else models[params['tts_model']][session['fine_tuned']]['voice']
+                params['gpt_cond_latent'], params['speaker_embedding'] = params['tts'].get_conditioning_latents(audio_path=[params['voice_file']])
+            else:
+                print(f"Loading TTS {params['tts_model']} model from {models[params['tts_model']][session['fine_tuned']]['repo']}...")
+                params['tts'] = XTTS(model_name=models[params['tts_model']][session['fine_tuned']]['repo'])
+                params['voice_file'] = session['voice_file'] if session['voice_file'] is not None else models[params['tts_model']][session['fine_tuned']]['voice']
+            params['tts'].to(session['device'])
+        else:
+            params['tts_model'] = 'fairseq'
+            model_repo = models[params['tts_model']][session['fine_tuned']]['repo'].replace("[lang]", session['metadata']['language'])
+            print(f"Loading TTS {model_repo} model from {model_repo}...")
+            params['tts'] = XTTS(model_repo)
+            params['voice_file'] = session['voice_file'] if session['voice_file'] is not None else models[params['tts_model']][session['fine_tuned']]['voice']
+            params['tts'].to(session['device'])
+
+        resume_chapter = 0
+        resume_sentence = 0
+
+        # Check existing files to resume the process if it was interrupted
+        existing_chapters = sorted([f for f in os.listdir(session['chapters_dir']) if f.endswith(f'.{audioproc_format}')])
+        existing_sentences = sorted([f for f in os.listdir(session['chapters_dir_sentences']) if f.endswith(f'.{audioproc_format}')])
+
+        if existing_chapters:
+            count_chapter_files = len(existing_chapters)
+            resume_chapter = count_chapter_files - 1 if count_chapter_files > 0 else 0
+            print(f'Resuming from chapter {count_chapter_files}')
+        if existing_sentences:
+            resume_sentence = len(existing_sentences)
+            print(f'Resuming from sentence {resume_sentence}')
+
+        total_chapters = len(session['chapters'])
+        total_sentences = sum(len(array) for array in session['chapters'])
+        current_sentence = 0
+
+        with tqdm(total=total_sentences, desc='convert_chapters_to_audio 0.00%', bar_format='{desc}: {n_fmt}/{total_fmt} ', unit='step', initial=resume_sentence) as t:
+            t.n = resume_sentence
+            t.refresh()
+            for x in range(resume_chapter, total_chapters):
+                chapter_num = x + 1
+                chapter_audio_file = f'chapter_{chapter_num}.{audioproc_format}'
+                sentences = session['chapters'][x]
+                sentences_count = len(sentences)
+                start = current_sentence  # Mark the starting sentence of the chapter
+                print(f"\nChapter {chapter_num} containing {sentences_count} sentences...")
+                for i, sentence in enumerate(sentences):
+                    if current_sentence >= resume_sentence:
+                        params['sentence_audio_file'] = os.path.join(session['chapters_dir_sentences'], f'{current_sentence}.{audioproc_format}')                       
+                        params['sentence'] = sentence
+                        if convert_sentence_to_audio(params, session):
+                            t.update(1)
+                            percentage = (current_sentence / total_sentences) * 100
+                            t.set_description(f'Processing {percentage:.2f}%')
+                            print(f'Sentence: {sentence}')
+                            t.refresh()
+                            if progress_bar is not None:
+                                progress_bar(current_sentence / total_sentences)
+                        else:
+                            return False
+                    current_sentence += 1
+                end = current_sentence - 1
+                print(f"\nEnd of Chapter {chapter_num}")
+                if start >= resume_sentence:
+                    if combine_audio_sentences(chapter_audio_file, start, end, session):
+                        print(f'Combining chapter {chapter_num} to audio, sentence {start} to {end}')
+                    else:
+                        print('combine_audio_sentences() failed!')
+                        return False
+        return True
+    except Exception as e:
+        raise DependencyError(e)
+
+def convert_sentence_to_audio(params, session):
+    try:
+        if session['cancellation_requested']:
+            #stop_and_detach_tts(params['tts'])
+            print('Cancel requested')
+            return False
+        generation_params = {
+            "temperature": session['temperature'],
+            "length_penalty": session["length_penalty"],
+            "repetition_penalty": session['repetition_penalty'],
+            "num_beams": int(session['length_penalty']) + 1 if session["length_penalty"] > 1 else 1,
+            "top_k": session['top_k'],
+            "top_p": session['top_p'],
+            "speed": session['speed'],
+            "enable_text_splitting": session['enable_text_splitting']
+        }
+        if params['tts_model'] == 'xtts':
+            if session['custom_model'] is not None or session['fine_tuned'] != 'std':
+                output = params['tts'].inference(
+                    text=params['sentence'],
+                    language=session['metadata']['language_iso1'],
+                    gpt_cond_latent=params['gpt_cond_latent'],
+                    speaker_embedding=params['speaker_embedding'],
+                    **generation_params
+                )
+                torchaudio.save(
+                    params['sentence_audio_file'], 
+                    torch.tensor(output[audioproc_format]).unsqueeze(0), 
+                    sample_rate=24000
+                )
+            else:
+                params['tts'].tts_to_file(
+                    text=params['sentence'],
+                    language=session['metadata']['language_iso1'],
+                    file_path=params['sentence_audio_file'],
+                    speaker_wav=params['voice_file'],
+                    **generation_params
+                )
+        elif params['tts_model'] == 'fairseq':
+            params['tts'].tts_with_vc_to_file(
+                text=params['sentence'],
+                file_path=params['sentence_audio_file'],
+                speaker_wav=params['voice_file'].replace('_24khz','_16khz'),
+                split_sentences=session['enable_text_splitting']
+            )
+        if os.path.exists(params['sentence_audio_file']):
+            return True
+        print(f"Cannot create {params['sentence_audio_file']}")
+        return False
+    except Exception as e:
+        raise DependencyError(e)
+        
+def combine_audio_sentences(chapter_audio_file, start, end, session):
+    try:
+        chapter_audio_file = os.path.join(session['chapters_dir'], chapter_audio_file)
+        combined_audio = AudioSegment.empty()  
+        # Get all audio sentence files sorted by their numeric indices
+        sentence_files = [f for f in os.listdir(session['chapters_dir_sentences']) if f.endswith(".wav")]
+        sentences_dir_ordered = sorted(sentence_files, key=lambda x: int(re.search(r'\d+', x).group()))
+        # Filter the files in the range [start, end]
+        selected_files = [
+            file for file in sentences_dir_ordered 
+            if start <= int(''.join(filter(str.isdigit, os.path.basename(file)))) <= end
+        ]
+        for file in selected_files:
+            if session['cancellation_requested']:
+                #stop_and_detach_tts(params['tts'])
+                print('Cancel requested')
+                return False
+            if session['cancellation_requested']:
+                msg = 'Cancel requested'
+                raise ValueError(msg)
+            audio_segment = AudioSegment.from_file(os.path.join(session['chapters_dir_sentences'],file), format=audioproc_format)
+            combined_audio += audio_segment
+        combined_audio.export(chapter_audio_file, format=audioproc_format)
+        print(f'Combined audio saved to {chapter_audio_file}')
+        return True
+    except Exception as e:
+        raise DependencyError(e)
+
+
+def combine_audio_chapters(session):
+    def sort_key(chapter_file):
+        numbers = re.findall(r'\d+', chapter_file)
+        return int(numbers[0]) if numbers else 0
+        
+    def assemble_audio():
+        try:
+            combined_audio = AudioSegment.empty()
+            batch_size = 256
+            # Process the chapter files in batches
+            for i in range(0, len(chapter_files), batch_size):
+                batch_files = chapter_files[i:i + batch_size]
+                batch_audio = AudioSegment.empty()  # Initialize an empty AudioSegment for the batch
+                # Sequentially append each file in the current batch to the batch_audio
+                for chapter_file in batch_files:
+                    if session['cancellation_requested']:
+                        print('Cancel requested')
+                        return False
+                    audio_segment = AudioSegment.from_wav(os.path.join(session['chapters_dir'],chapter_file))
+                    batch_audio += audio_segment
+                combined_audio += batch_audio
+            combined_audio.export(assembled_audio, format=audioproc_format)
+            print(f'Combined audio saved to {assembled_audio}')
+            return True
+        except Exception as e:
+            raise DependencyError(e)
+
+    def generate_ffmpeg_metadata():
+        try:
+            if session['cancellation_requested']:
+                print('Cancel requested')
+                return False
+            ffmpeg_metadata = ';FFMETADATA1\n'        
+            if session['metadata'].get('title'):
+                ffmpeg_metadata += f"title={session['metadata']['title']}\n"            
+            if session['metadata'].get('creator'):
+                ffmpeg_metadata += f"artist={session['metadata']['creator']}\n"
+            if session['metadata'].get('language'):
+                ffmpeg_metadata += f"language={session['metadata']['language']}\n\n"
+            if session['metadata'].get('publisher'):
+                ffmpeg_metadata += f"publisher={session['metadata']['publisher']}\n"              
+            if session['metadata'].get('description'):
+                ffmpeg_metadata += f"description={session['metadata']['description']}\n"
+            if session['metadata'].get('published'):
+                # Check if the timestamp contains fractional seconds
+                if '.' in session['metadata']['published']:
+                    # Parse with fractional seconds
+                    year = datetime.strptime(session['metadata']['published'], '%Y-%m-%dT%H:%M:%S.%f%z').year
+                else:
+                    # Parse without fractional seconds
+                    year = datetime.strptime(session['metadata']['published'], '%Y-%m-%dT%H:%M:%S%z').year
+            else:
+                # If published is not provided, use the current year
+                year = datetime.now().year
+            ffmpeg_metadata += f'year={year}\n'
+            if session['metadata'].get('identifiers') and isinstance(session['metadata'].get('identifiers'), dict):
+                isbn = session['metadata']['identifiers'].get('isbn', None)
+                if isbn:
+                    ffmpeg_metadata += f'isbn={isbn}\n'  # ISBN
+                mobi_asin = session['metadata']['identifiers'].get('mobi-asin', None)
+                if mobi_asin:
+                    ffmpeg_metadata += f'asin={mobi_asin}\n'  # ASIN                   
+            start_time = 0
+            for index, chapter_file in enumerate(chapter_files):
+                if session['cancellation_requested']:
+                    msg = 'Cancel requested'
+                    raise ValueError(msg)
+
+                duration_ms = len(AudioSegment.from_wav(os.path.join(session['chapters_dir'],chapter_file)))
+                ffmpeg_metadata += f'[CHAPTER]\nTIMEBASE=1/1000\nSTART={start_time}\n'
+                ffmpeg_metadata += f'END={start_time + duration_ms}\ntitle=Chapter {index + 1}\n'
+                start_time += duration_ms
+            # Write the metadata to the file
+            with open(metadata_file, 'w', encoding='utf-8') as file:
+                file.write(ffmpeg_metadata)
+            return True
+        except Exception as e:
+            raise DependencyError(e)
+
+    def export_audio():
+        try:
+            if session['cancellation_requested']:
+                print('Cancel requested')
+                return False
+            ffmpeg_cover = None
+            if session['script_mode'] == DOCKER_UTILS:
+                docker_dir = os.path.basename(session['tmp_dir'])
+                ffmpeg_combined_audio = f'/files/{docker_dir}/' + os.path.basename(assembled_audio)
+                ffmpeg_metadata_file = f'/files/{docker_dir}/' + os.path.basename(metadata_file)
+                ffmpeg_final_file = f'/files/{docker_dir}/' + os.path.basename(docker_final_file)           
+                if session['cover'] is not None:
+                    ffmpeg_cover = f'/files/{docker_dir}/' + os.path.basename(session['cover'])                   
+                ffmpeg_cmd = ['ffmpeg', '-i', ffmpeg_combined_audio, '-i', ffmpeg_metadata_file]
+            else:
+                ffmpeg_combined_audio = assembled_audio
+                ffmpeg_metadata_file = metadata_file
+                ffmpeg_final_file = final_file
+                if session['cover'] is not None:
+                    ffmpeg_cover = session['cover']                    
+                ffmpeg_cmd = [shutil.which('ffmpeg'), '-i', ffmpeg_combined_audio, '-i', ffmpeg_metadata_file]
+            if ffmpeg_cover is not None:
+                ffmpeg_cmd += ['-i', ffmpeg_cover, '-map', '0:a', '-map', '2:v']
+            else:
+                ffmpeg_cmd += ['-map', '0:a'] 
+            ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '128k', '-ar', '44100']           
+            if ffmpeg_cover is not None:
+                if ffmpeg_cover.endswith('.png'):
+                    ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']  # PNG cover
+                else:
+                    ffmpeg_cmd += ['-c:v', 'copy', '-disposition:v', 'attached_pic']  # JPEG cover (no re-encoding needed)                    
+            if ffmpeg_cover is not None and ffmpeg_cover.endswith('.png'):
+                ffmpeg_cmd += ['-pix_fmt', 'yuv420p']            
+            ffmpeg_cmd += [
+                '-af', 
+                'agate=threshold=-35dB:ratio=1.5:attack=10:release=200,acompressor=threshold=-20dB:ratio=2:attack=80:release=200:makeup=1dB,loudnorm=I=-19:TP=-3:LRA=7:linear=true,afftdn=nf=-50,equalizer=f=150:t=q:w=2:g=2,equalizer=f=250:t=q:w=2:g=-2,equalizer=f=12000:t=q:w=2:g=2',
+                '-movflags', '+faststart', '-y', ffmpeg_final_file
+            ]
+            if session['script_mode'] == DOCKER_UTILS:
+                try:
+                    container = session['client'].containers.run(
+                        docker_utils_image,
+                        command=ffmpeg_cmd,
+                        volumes={session['tmp_dir']: {'bind': f'/files/{docker_dir}', 'mode': 'rw'}},
+                        remove=True,
+                        detach=False,
+                        stdout=True,
+                        stderr=True
+                    )
+                    print(container.decode('utf-8'))
+                    if shutil.copy(docker_final_file, final_file):
+                        return True
+                    return False
+                except docker.errors.ContainerError as e:
+                    raise DependencyError(e)
+                except docker.errors.ImageNotFound as e:
+                    raise DependencyError(e)
+                except docker.errors.APIError as e:
+                    raise DependencyError(e)
+            else:
+                try:
+                    subprocess.run(ffmpeg_cmd, env={}, check=True)
+                    return True
+                except subprocess.CalledProcessError as e:
+                    raise DependencyError(e)
+ 
+        except Exception as e:
+            raise DependencyError(e)
+
+    try:
+        chapter_files = [f for f in os.listdir(session['chapters_dir']) if f.endswith(".wav")]
+        chapter_files = sorted(chapter_files, key=lambda x: int(re.search(r'\d+', x).group()))
+        assembled_audio = os.path.join(session['tmp_dir'], session['metadata']['title'] + '.' + audioproc_format)
+        metadata_file = os.path.join(session['tmp_dir'], 'metadata.txt')
+        if assemble_audio():
+            if generate_ffmpeg_metadata():
+                final_name = session['metadata']['title'] + '.' + audiobook_format
+                docker_final_file = os.path.join(session['tmp_dir'], final_name)
+                final_file = os.path.join(session['audiobooks_dir'], final_name)       
+                if export_audio():
+                    return final_file
+        return None
+    except Exception as e:
+        raise DependencyError(e)        
+
+def replace_roman_numbers(text):
+    def roman_to_int(s):
+        try:
+            roman = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000,
+                     'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90, 'CD': 400, 'CM': 900}   
+            i = 0
+            num = 0   
+            # Iterate over the string to calculate the integer value
+            while i < len(s):
+                # Check for two-character numerals (subtractive combinations)
+                if i + 1 < len(s) and s[i:i+2] in roman:
+                    num += roman[s[i:i+2]]
+                    i += 2
+                else:
+                    # Add the value of the single character
+                    num += roman[s[i]]
+                    i += 1   
+            return num
+        except Exception as e:
+            return s
+
+    roman_chapter_pattern = re.compile(
+        r'\b(chapter|volume|chapitre|tome|capitolo|capítulo|volumen|Kapitel|глава|том|κεφάλαιο|τόμος|capitul|poglavlje)\s'
+        r'(M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|[IVXLCDM]+)\b',
+        re.IGNORECASE
+    )
+
+    roman_numerals_with_period = re.compile(
+        r'^(M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})|[IVXLCDM])\.+'
+    )
+
+    def replace_chapter_match(match):
+        chapter_word = match.group(1)
+        roman_numeral = match.group(2)
+        integer_value = roman_to_int(roman_numeral.upper())
+        return f'{chapter_word.capitalize()} {integer_value}'
+
+    def replace_numeral_with_period(match):
+        roman_numeral = match.group(1)
+        integer_value = roman_to_int(roman_numeral)
+        return f'{integer_value}.'
+
+    text = roman_chapter_pattern.sub(replace_chapter_match, text)
+    text = roman_numerals_with_period.sub(replace_numeral_with_period, text)
+    return text
+'''
+def stop_and_detach_tts(tts=None):
+    if tts is not None:
+        if next(tts.parameters()).is_cuda:
+            tts.to('cpu')
+        del tts
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+'''
+def delete_old_web_folders(root_dir):
+    try:
+        if not os.path.exists(root_dir):
+            os.makedirs(root_dir)
+            print(f'Created missing directory: {root_dir}')
+        current_time = time.time()
+        age_limit = current_time - interface_shared_expire * 60 * 60  # 24 hours in seconds
+        for folder_name in os.listdir(root_dir):
+            dir_path = os.path.join(root_dir, folder_name)
+            if os.path.isdir(dir_path) and folder_name.startswith('web-'):
+                folder_creation_time = os.path.getctime(dir_path)
+                if folder_creation_time < age_limit:
+                    shutil.rmtree(dir_path)
+    except Exception as e:
+        raise DependencyError(e)
+
+def compare_file_metadata(f1, f2):
+    if os.path.getsize(f1) != os.path.getsize(f2):
+        return False
+    if os.path.getmtime(f1) != os.path.getmtime(f2):
+        return False
+    return True
+
+def convert_ebook(args):
+    try:
+        global is_gui_process
+        global context        
+        error = None
+        try:
+            if len(args['language']) == 2:
+                lang_array = languages.get(alpha2=args['language'])
+                if lang_array and lang_array.part3:
+                    args['language'] = lang_array.part3
+                else:
+                    args['language'] = None
+            else:
+                lang_array = languages.get(part3=args['language'])               
+                if not lang_array:
+                    args['language'] = None
+        except Exception as e:
+            args['language'] = None
+            pass
+
+        if args['language'] is not None and args['language'] in language_mapping.keys():
+            session_id = args['session'] if args['session'] is not None else str(uuid.uuid4())
+            session = context.get_session(session_id)
+            session['id'] = session_id
+            session['src'] = args['ebook']
+            session['script_mode'] = args['script_mode'] if args['script_mode'] is not None else NATIVE       
+            session['audiobooks_dir'] = args['audiobooks_dir']
+            is_gui_process = args['is_gui_process']
+            device = args['device'].lower()
+            voice_file = args['voice']
+            language = args['language']
+            temperature = args['temperature']
+            length_penalty = args['length_penalty']
+            repetition_penalty = args['repetition_penalty']
+            top_k = args['top_k']
+            top_p = args['top_p']
+            speed = args['speed']
+            enable_text_splitting = args['enable_text_splitting'] if args['enable_text_splitting'] is not None else True
+            custom_model_file = args['custom_model'] if args['custom_model'] != 'none'  and args['custom_model'] is not None else None
+            fine_tuned = args['fine_tuned'] if check_fine_tuned(args['fine_tuned'], args['language']) else None
+            
+            if not fine_tuned:
+                raise ValueError('The fine tuned model does not exist.')
+
+            if not os.path.splitext(args['ebook'])[1]:
+                raise ValueError('The selected ebook file has no extension. Please select a valid file.')
+
+            if session['script_mode'] == NATIVE:
+                bool, e = check_programs('Calibre', 'calibre', '--version')
+                if not bool:
+                    raise DependencyError(e)
+                bool, e = check_programs('FFmpeg', 'ffmpeg', '-version')
+                if not bool:
+                    raise DependencyError(e)
+            elif session['script_mode'] == DOCKER_UTILS:
+                session['client'] = docker.from_env()
+
+            session['tmp_dir'] = os.path.join(processes_dir, f"ebook-{session['id']}")
+            session['chapters_dir'] = os.path.join(session['tmp_dir'], f"chapters_{hashlib.md5(args['ebook'].encode()).hexdigest()}")
+            session['chapters_dir_sentences'] = os.path.join(session['chapters_dir'], 'sentences')
+
+            if not is_gui_process:
+                print(f'*********** Session: {session_id}', '************* Store it in case of interruption or crash you can resume the conversion')
+                session['custom_model_dir'] = os.path.join(models_dir,'__sessions',f"model-{session['id']}")
+                if custom_model_file:
+                    session['custom_model'], progression_status = extract_custom_model(custom_model_file, session['custom_model_dir'])
+                    if not session['custom_model']:
+                        raise ValueError(f'{custom_model_file} could not be extracted or mandatory files are missing')
+
+            if prepare_dirs(args['ebook'], session):
+                session['filename_noext'] = os.path.splitext(os.path.basename(session['src']))[0]
+                if not torch.cuda.is_available() or device == 'cpu':
+                    if device == 'gpu':
+                        print('GPU is not available on your device!')
+                    device = 'cpu'
+                else:
+                    device = 'cuda'
+                torch.device(device)
+                print(f'Available Processor Unit: {device}')   
+                session['epub_path'] = os.path.join(session['tmp_dir'], '__' + session['filename_noext'] + '.epub')
+                has_src_metadata = has_metadata(session['src'])
+                if convert_to_epub(session):
+                    session['epub'] = epub.read_epub(session['epub_path'], {'ignore_ncx': True})       
+                    metadata = dict(session['metadata'])
+                    for key, value in metadata.items():
+                        data = session['epub'].get_metadata('DC', key)
+                        if data:
+                            for value, attributes in data:
+                                if key == 'language' and not has_src_metadata:
+                                    session['metadata'][key] = language
+                                else:
+                                    session['metadata'][key] = value
+                    language_array = languages.get(part3=language)
+                    if language_array and language_array.part1:
+                        session['metadata']['language_iso1'] = language_array.part1
+                    if session['metadata']['language'] == language or session['metadata']['language_iso1'] and session['metadata']['language'] == session['metadata']['language_iso1']:
+                        session['metadata']['title'] = os.path.splitext(os.path.basename(session['src']))[0] if not session['metadata']['title'] else session['metadata']['title']
+                        session['metadata']['creator'] =  False if not session['metadata']['creator'] else session['metadata']['creator']
+                        session['cover'] = get_cover(session)
+                        if session['cover']:
+                            session['chapters'] = get_chapters(language, session)
+                            if session['chapters']:
+                                session['device'] = device
+                                session['temperature'] = temperature
+                                session['length_penalty'] = length_penalty
+                                session['repetition_penalty'] = repetition_penalty
+                                session['top_k'] = top_k
+                                session['top_p'] = top_p
+                                session['speed'] = speed
+                                session['enable_text_splitting'] = enable_text_splitting
+                                session['fine_tuned'] = fine_tuned
+                                session['voice_file'] = voice_file
+                                session['language'] = language
+                                if convert_chapters_to_audio(session):
+                                    final_file = combine_audio_chapters(session)               
+                                    if final_file is not None:
+                                        chapters_dirs = [
+                                            dir_name for dir_name in os.listdir(session['tmp_dir'])
+                                            if fnmatch.fnmatch(dir_name, "chapters_*") and os.path.isdir(os.path.join(session['tmp_dir'], dir_name))
+                                        ]
+                                        if len(chapters_dirs) > 1:
+                                            if os.path.exists(session['chapters_dir']):
+                                                shutil.rmtree(session['chapters_dir'])
+                                            if os.path.exists(session['epub_path']):
+                                                os.remove(session['epub_path'])
+                                            if os.path.exists(session['cover']):
+                                                os.remove(session['cover'])
+                                        else:
+                                            if os.path.exists(session['tmp_dir']):
+                                                shutil.rmtree(session['tmp_dir'])
+                                        progress_status = f'Audiobook {os.path.basename(final_file)} created!'
+                                        return progress_status, final_file 
+                                    else:
+                                        error = 'combine_audio_chapters() error: final_file not created!'
+                                else:
+                                    error = 'convert_chapters_to_audio() failed!'
+                            else:
+                                error = 'get_chapters() failed!'
+                        else:
+                            error = 'get_cover() failed!'
+                    else:
+                        error = f"WARNING: Ebook language: {session['metadata']['language']}, language selected: {language}"
+                else:
+                    error = 'convert_to_epub() failed!'
+            else:
+                error = f"Temporary directory {session['tmp_dir']} not removed due to failure."
+        else:
+            error = f"Language {args['language']} is not supported."
+        if session['cancellation_requested']:
+            error = 'Cancelled'
+        print(error)
+        return error, None
+    except Exception as e:
+        print(f'convert_ebook() Exception: {e}')
+        return e, None
+
+def web_interface(args):
+    script_mode = args['script_mode']
+    is_gui_process = args['is_gui_process']
+    is_gui_shared = args['share']
+    is_converting = False
+    audiobooks_dir = None
+    ebook_src = None
+    audiobook_file = None
+    language_options = [
+        (
+            f"{details['name']} - {details['native_name']}" if details['name'] != details['native_name'] else details['name'],
+            lang
+        )
+        for lang, details in language_mapping.items()
+    ]
+    custom_model_options = None
+    fine_tuned_options = list(models['xtts'].keys())
+    default_language_name =  next((name for name, key in language_options if key == default_language_code), None)
+
+    theme = gr.themes.Origin(
+        primary_hue='amber',
+        secondary_hue='green',
+        neutral_hue='gray',
+        radius_size='lg',
+        font_mono=['JetBrains Mono', 'monospace', 'Consolas', 'Menlo', 'Liberation Mono']
+    )
+    
+    with gr.Blocks(theme=theme) as interface:
+        gr.HTML(
+            '''
+            <style>
+                .svelte-1xyfx7i.center.boundedheight.flex{
+                    height: 120px !important;
+                }
+                .block.svelte-5y6bt2 {
+                    padding: 10px !important;
+                    margin: 0 !important;
+                    height: auto !important;
+                    font-size: 16px !important;
+                }
+                .wrap.svelte-12ioyct {
+                    padding: 0 !important;
+                    margin: 0 !important;
+                    font-size: 12px !important;
+                }
+                .block.svelte-5y6bt2.padded {
+                    height: auto !important;
+                    padding: 10px !important;
+                }
+                .block.svelte-5y6bt2.padded.hide-container {
+                    height: auto !important;
+                    padding: 0 !important;
+                }
+                .waveform-container.svelte-19usgod {
+                    height: 58px !important;
+                    overflow: hidden !important;
+                    padding: 0 !important;
+                    margin: 0 !important;
+                }
+                .component-wrapper.svelte-19usgod {
+                    height: 110px !important;
+                }
+                .timestamps.svelte-19usgod {
+                    display: none !important;
+                }
+                .controls.svelte-ije4bl {
+                    padding: 0 !important;
+                    margin: 0 !important;
+                }
+                #component-7, #component-10, #component-20 {
+                    height: 140px !important;
+                }
+                #component-47, #component-51 {
+                    height: 100px !important;
+                }
+            </style>
+            '''
+        )
+        gr.Markdown(
+            f'''
+            # Ebook2Audiobook v{version}<br/>
+            https://github.com/DrewThomasson/ebook2audiobook<br/>
+            Convert eBooks into immersive audiobooks with realistic voice TTS models.<br/>
+            Multiuser, multiprocessing, multithread on a geo cluster to share the conversion to the Grid.
+            '''
+        )
+        with gr.Tabs():
+            gr_tab_main = gr.TabItem('Input Options')
+            with gr_tab_main:
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        with gr.Group():
+                            gr_ebook_file = gr.File(label='EBook File (.epub, .mobi, .azw3, fb2, lrf, rb, snb, tcr, .pdf, .txt, .rtf, doc, .docx, .html, .odt, .azw)', file_types=['.epub', '.mobi', '.azw3', 'fb2', 'lrf', 'rb', 'snb', 'tcr', '.pdf', '.txt', '.rtf', 'doc', '.docx', '.html', '.odt', '.azw'])
+                        with gr.Group():
+                            gr_voice_file = gr.File(label='*Cloning Voice (a .wav 24khz for XTTS base model and 16khz for FAIRSEQ base model, no more than 6 sec)', file_types=['.wav'], visible=interface_component_options['gr_voice_file'])
+                            gr.Markdown('<p>&nbsp;&nbsp;* Optional</p>')
+                        with gr.Group():
+                            gr_device = gr.Radio(label='Processor Unit', choices=['CPU', 'GPU'], value='CPU')
+                        with gr.Group():
+                            gr_language = gr.Dropdown(label='Language', choices=[name for name, _ in language_options], value=default_language_name)
+                    with gr.Column(scale=3):
+                        gr_group_custom_model = gr.Group(visible=interface_component_options['gr_group_custom_model'])
+                        with gr_group_custom_model:
+                            gr_custom_model_file = gr.File(label='*Custom XTTS Model (a .zip containing config.json, vocab.json, model.pth, ref.wav)', file_types=['.zip'])
+                            gr_custom_model_list = gr.Dropdown(label='', choices=['none'], interactive=True)
+                            gr.Markdown('<p>&nbsp;&nbsp;* Optional</p>')
+                        with gr.Group():
+                            gr_session_status = gr.Textbox(label='Session')
+                        with gr.Group():
+                            gr_tts_engine = gr.Dropdown(label='TTS Base', choices=[default_tts_engine], value=default_tts_engine, interactive=True)
+                            gr_fine_tuned = gr.Dropdown(label='Fine Tuned Models', choices=fine_tuned_options, value=default_fine_tuned, interactive=True)
+            gr_tab_preferences = gr.TabItem('Audio Generation Preferences', visible=interface_component_options['gr_tab_preferences'])
+            with gr_tab_preferences:
+                gr.Markdown(
+                    '''
+                    ### Customize Audio Generation Parameters
+                    Adjust the settings below to influence how the audio is generated. You can control the creativity, speed, repetition, and more.
+                    '''
+                )
+                gr_temperature = gr.Slider(
+                    label='Temperature', 
+                    minimum=0.1, 
+                    maximum=10.0, 
+                    step=0.1, 
+                    value=0.65,
+                    info='Higher values lead to more creative, unpredictable outputs. Lower values make it more monotone.'
+                )
+                gr_length_penalty = gr.Slider(
+                    label='Length Penalty', 
+                    minimum=0.5, 
+                    maximum=10.0, 
+                    step=0.1, 
+                    value=1.0, 
+                    info='Penalize longer sequences. Higher values produce shorter outputs. Not applied to custom models.'
+                )
+                gr_repetition_penalty = gr.Slider(
+                    label='Repetition Penalty', 
+                    minimum=1.0, 
+                    maximum=10.0, 
+                    step=0.1, 
+                    value=2.5, 
+                    info='Penalizes repeated phrases. Higher values reduce repetition.'
+                )
+                gr_top_k = gr.Slider(
+                    label='Top-k Sampling', 
+                    minimum=10, 
+                    maximum=100, 
+                    step=1, 
+                    value=50, 
+                    info='Lower values restrict outputs to more likely words and increase speed at which audio generates.'
+                )
+                gr_top_p = gr.Slider(
+                    label='Top-p Sampling', 
+                    minimum=0.1, 
+                    maximum=1.0, 
+                    step=.01, 
+                    value=0.8, 
+                    info='Controls cumulative probability for word selection. Lower values make the output more predictable and increase speed at which audio generates.'
+                )
+                gr_speed = gr.Slider(
+                    label='Speed', 
+                    minimum=0.5, 
+                    maximum=3.0, 
+                    step=0.1, 
+                    value=1.0, 
+                    info='Adjusts how fast the narrator will speak.'
+                )
+                gr_enable_text_splitting = gr.Checkbox(
+                    label='Enable Text Splitting', 
+                    value=True,
+                    info='Splits long texts into sentences to generate audio in chunks. Useful for very long inputs.'
+                )
+                
+        gr_state = gr.State(value="")  # Initialize state for each user session
+        gr_session = gr.Textbox(label='Session', visible=False)
+        gr_conversion_progress = gr.Textbox(label='Progress')
+        gr_convert_btn = gr.Button('Convert', variant='primary', interactive=False)
+        gr_audio_player = gr.Audio(label='Listen', type='filepath', show_download_button=False, container=True, visible=False)
+        gr_audiobooks_ddn = gr.Dropdown(choices=[], label='Audiobooks')
+        gr_audiobook_link = gr.File(label='Download')
+        gr_write_data = gr.JSON(visible=False)
+        gr_read_data = gr.JSON(visible=False)
+        gr_data = gr.State({})
+        gr_modal_html = gr.HTML()
+
+        def show_modal(message):
+            return f'''
+            <style>
+                .modal {{
+                    display: none; /* Hidden by default */
+                    position: fixed;
+                    top: 0;
+                    left: 0;
+                    width: 100%;
+                    height: 100%;
+                    background-color: rgba(0, 0, 0, 0.5);
+                    z-index: 9999;
+                    display: flex;
+                    justify-content: center;
+                    align-items: center;
+                }}
+                .modal-content {{
+                    background-color: #333;
+                    padding: 20px;
+                    border-radius: 8px;
+                    text-align: center;
+                    max-width: 300px;
+                    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5);
+                    border: 2px solid #FFA500;
+                    color: white;
+                    font-family: Arial, sans-serif;
+                    position: relative;
+                }}
+                .modal-content p {{
+                    margin: 10px 0;
+                }}
+                /* Spinner */
+                .spinner {{
+                    margin: 15px auto;
+                    border: 4px solid rgba(255, 255, 255, 0.2);
+                    border-top: 4px solid #FFA500;
+                    border-radius: 50%;
+                    width: 30px;
+                    height: 30px;
+                    animation: spin 1s linear infinite;
+                }}
+                @keyframes spin {{
+                    0% {{ transform: rotate(0deg); }}
+                    100% {{ transform: rotate(360deg); }}
+                }}
+            </style>
+            <div id="custom-modal" class="modal">
+                <div class="modal-content">
+                    <p>{message}</p>
+                    <div class="spinner"></div> <!-- Spinner added here -->
+                </div>
+            </div>
+            '''
+
+        def hide_modal():
+            return ''
+
+        def update_interface():
+            nonlocal is_converting
+            is_converting = False
+            return gr.update('Convert', variant='primary', interactive=False), gr.update(value=None), gr.update(value=None), gr.update(value=audiobook_file), update_audiobooks_ddn(), hide_modal()
+
+        def refresh_audiobook_list():
+            files = []
+            if audiobooks_dir is not None:
+                if os.path.exists(audiobooks_dir):
+                    files = [f for f in os.listdir(audiobooks_dir)]
+                    files.sort(key=lambda x: os.path.getmtime(os.path.join(audiobooks_dir, x)), reverse=True)
+            return files
+
+        def change_gr_audiobooks_ddn(audiobook):
+            if audiobooks_dir is not None:
+                if audiobook:
+                    link = os.path.join(audiobooks_dir, audiobook)
+                    return link, link, gr.update(visible=True)
+            return None, None, gr.update(visible=False)
+            
+        def update_convert_btn(upload_file=None, custom_model_file=None, session_id=None):
+            if session_id is None:
+                yield gr.update(variant='primary', interactive=False)
+                return
+            else:
+                session = context.get_session(session_id)
+                if hasattr(upload_file, 'name') and not hasattr(custom_model_file, 'name'):
+                    yield gr.update(variant='primary', interactive=True)
+                else:
+                    yield gr.update(variant='primary', interactive=False)   
+                return
+
+        def update_audiobooks_ddn():
+            files = refresh_audiobook_list()
+            return gr.update(choices=files, label='Audiobooks', value=files[0] if files else None)
+
+        async def change_gr_ebook_file(f, session_id):
+            nonlocal is_converting
+            if context and session_id:
+                session = context.get_session(session_id)
+                if f is None:
+                    if is_converting:
+                        session['cancellation_requested'] = True
+                        yield show_modal('Cancellation requested, please wait...')
+                        return
+            session['cancellation_requested'] = False
+            yield hide_modal()
+            return
+        
+        def change_gr_language(selected: str, session_id: str):
+            nonlocal custom_model_options
+            if selected == 'zzzz':
+                new_language_name = default_language_name
+                new_language_key = default_language_code
+            else:
+                new_language_name, new_language_key = next(((name, key) for name, key in language_options if key == selected), (None, None))
+            tts_engine_options = ['xtts'] if language_xtts.get(new_language_key, False) else ['fairseq']
+            fine_tuned_options = [
+                model_name
+                for model_name, model_details in models.get(tts_engine_options[0], {}).items()
+                if model_details.get('lang') == 'multi' or model_details.get('lang') == new_language_key
+            ]
+            custom_model_options = ['none']
+            if context and session_id:
+                session = context.get_session(session_id)
+                session['language'] = new_language_key
+                custom_model_tts = check_custom_model_tts(session)
+                custom_model_tts_dir = os.path.join(session['custom_model_dir'], custom_model_tts)
+                if os.path.exists(custom_model_tts_dir):
+                    custom_model_options += os.listdir(custom_model_tts_dir)
+            return (
+                gr.update(value=new_language_name),
+                gr.update(choices=tts_engine_options, value=tts_engine_options[0]),
+                gr.update(choices=fine_tuned_options, value=fine_tuned_options[0] if fine_tuned_options else 'none'),
+                gr.update(choices=custom_model_options, value=custom_model_options[0])
+            )
+
+        def check_custom_model_tts(session):
+            custom_model_tts = 'xtts'
+            if not language_xtts.get(session['language']):
+                custom_model_tts = 'fairseq'
+            custom_model_tts_dir = os.path.join(session['custom_model_dir'], custom_model_tts)
+            if not os.path.isdir(custom_model_tts_dir):
+                os.makedirs(custom_model_tts_dir, exist_ok=True)
+            return custom_model_tts
+
+        def change_gr_custom_model_list(custom_model_list):
+            if custom_model_list == 'none':
+                return gr.update(visible=True)
+            return gr.update(visible=False)
+            
+        async def change_gr_custom_model_file(custom_model_file, session_id):
+            try:
+                nonlocal custom_model_options, gr_custom_model_file, gr_conversion_progress
+                if context and session_id:
+                    session = context.get_session(session_id)
+                    if custom_model_file is not None:
+                        if analyze_uploaded_file(custom_model_file):                        
+                            session['custom_model'], progress_status = extract_custom_model(custom_model_file, None, session)
+                            if session['custom_model']:
+                                custom_model_tts_dir = check_custom_model_tts(session)
+                                custom_model_options = ['none'] + os.listdir(os.path.join(session['custom_model_dir'], custom_model_tts_dir))
+                                yield (
+                                    gr.update(visible=False),
+                                    gr.update(choices=custom_model_options, value=session['custom_model']),
+                                    gr.update(value=f"{session['custom_model']} added to the custom list")
+                                )
+                                gr_custom_model_file = gr.File(label='*XTTS Model (a .zip containing config.json, vocab.json, model.pth, ref.wav)', value=None, file_types=['.zip'])
+                                return
+                        yield gr.update(), gr.update(), gr.update(value='Invalid file! Please upload a valid ZIP.')
+                        return
+            except Exception as e:
+                yield gr.update(), gr.update(), gr.update(value=f'Error: {str(e)}')
+                return
+
+        def change_gr_tts_engine(engine):
+            if engine == 'xtts':
+                return gr.update(visible=True)
+            else:
+                return gr.update(visible=False)
+            
+        def change_gr_fine_tuned(fine_tuned):
+            visible = False
+            if fine_tuned == 'std':
+                visible = True
+            return gr.update(visible=visible)
+
+        def change_gr_data(data):
+            data['event'] = 'change_data'
+            return data
+
+        def change_gr_read_data(data):
+            nonlocal audiobooks_dir
+            nonlocal custom_model_options
+            warning_text_extra = ''
+            if not data:
+                data = {'session_id': str(uuid.uuid4())}
+                warning_text = f"Session: {data['session_id']}"
+            else:
+                if 'session_id' not in data:
+                    data['session_id'] = str(uuid.uuid4())
+                warning_text = data['session_id']
+                event = data.get('event', '')
+                if event != 'load':
+                    return [gr.update(), gr.update(), gr.update(), gr.update(), gr.update()]
+            session = context.get_session(data['session_id'])
+            session['custom_model_dir'] = os.path.join(models_dir,'__sessions',f"model-{session['id']}")
+            os.makedirs(session['custom_model_dir'], exist_ok=True)
+            custom_model_tts_dir = check_custom_model_tts(session)
+            custom_model_options = ['none'] + os.listdir(os.path.join(session['custom_model_dir'],custom_model_tts_dir))
+            if is_gui_shared:
+                warning_text_extra = f' Note: access limit time: {interface_shared_expire} hours'
+                audiobooks_dir = os.path.join(audiobooks_gradio_dir, f"web-{data['session_id']}")
+                delete_old_web_folders(audiobooks_gradio_dir)
+            else:
+                audiobooks_dir = os.path.join(audiobooks_host_dir, f"web-{data['session_id']}")
+            return [data, f'{warning_text}{warning_text_extra}', data['session_id'], update_audiobooks_ddn(), gr.update(choices=custom_model_options, value='none')]
+
+        def submit_convert_btn(
+            session, device, ebook_file, voice_file, language, 
+            custom_model_file, temperature, length_penalty,
+            repetition_penalty, top_k, top_p, speed, enable_text_splitting, fine_tuned
+        ):
+            nonlocal is_converting
+
+            args = {
+                "is_gui_process": is_gui_process,
+                "session": session,
+                "script_mode": script_mode,
+                "device": device.lower(),
+                "ebook": ebook_file.name if ebook_file else None,
+                "audiobooks_dir": audiobooks_dir,
+                "voice": voice_file.name if voice_file else None,
+                "language": next((key for name, key in language_options if name == language), None),
+                "custom_model": next((key for name, key in language_options if name != 'none'), None),
+                "temperature": float(temperature),
+                "length_penalty": float(length_penalty),
+                "repetition_penalty": float(repetition_penalty),
+                "top_k": int(top_k),
+                "top_p": float(top_p),
+                "speed": float(speed),
+                "enable_text_splitting": enable_text_splitting,
+                "fine_tuned": fine_tuned
+            }
+
+            if args["ebook"] is None:
+                yield gr.update(value='Error: a file is required.')
+                return
+
+            try:
+                is_converting = True
+                progress_status, audiobook_file = convert_ebook(args)
+                if audiobook_file is None:
+                    if is_converting:
+                        yield gr.update(value='Conversion cancelled.')
+                        return
+                    else:
+                        yield gr.update(value='Conversion failed.')
+                        return
+                else:
+                    yield progress_status
+                    return
+            except Exception as e:
+                yield DependencyError(e)
+                return
+
+        gr_ebook_file.change(
+            fn=update_convert_btn,
+            inputs=[gr_ebook_file, gr_custom_model_file, gr_session],
+            outputs=gr_convert_btn
+        ).then(
+            fn=change_gr_ebook_file,
+            inputs=[gr_ebook_file, gr_session],
+            outputs=[gr_modal_html]
+        )
+        gr_language.change(
+            fn=lambda selected, session_id: change_gr_language(dict(language_options).get(selected, 'Unknown'), session_id),
+            inputs=[gr_language, gr_session],
+            outputs=[gr_language, gr_tts_engine, gr_fine_tuned, gr_custom_model_list]
+        )
+        gr_audiobooks_ddn.change(
+            fn=change_gr_audiobooks_ddn,
+            inputs=gr_audiobooks_ddn,
+            outputs=[gr_audiobook_link, gr_audio_player, gr_audio_player]
+        )
+        gr_custom_model_file.change(
+            fn=change_gr_custom_model_file,
+            inputs=[gr_custom_model_file, gr_session],
+            outputs=[gr_fine_tuned, gr_custom_model_list, gr_conversion_progress]
+        )
+        gr_custom_model_list.change(
+            fn=change_gr_custom_model_list,
+            inputs=gr_custom_model_list,
+            outputs=gr_fine_tuned
+        )
+        gr_tts_engine.change(
+            fn=change_gr_tts_engine,
+            inputs=gr_tts_engine,
+            outputs=gr_tab_preferences
+        )
+        gr_fine_tuned.change(
+            fn=change_gr_fine_tuned,
+            inputs=gr_fine_tuned,
+            outputs=gr_group_custom_model
+        )
+        gr_session.change(
+            fn=change_gr_data,
+            inputs=gr_data,
+            outputs=gr_write_data
+        )
+        gr_write_data.change(
+            fn=None,
+            inputs=gr_write_data,
+            js='''
+            (data) => {
+              localStorage.clear();
+              console.log(data);
+              window.localStorage.setItem('data', JSON.stringify(data));
+            }
+            '''
+        )       
+        gr_read_data.change(
+            fn=change_gr_read_data,
+            inputs=gr_read_data,
+            outputs=[gr_data, gr_session_status, gr_session, gr_audiobooks_ddn, gr_custom_model_list]
+        )       
+        gr_convert_btn.click(
+            fn=update_convert_btn,
+            inputs=None,
+            outputs=gr_convert_btn
+        ).then(
+            fn=submit_convert_btn,
+            inputs=[
+                gr_session, gr_device, gr_ebook_file, gr_voice_file, gr_language, 
+                gr_custom_model_list, gr_temperature, gr_length_penalty,
+                gr_repetition_penalty, gr_top_k, gr_top_p, gr_speed, gr_enable_text_splitting, gr_fine_tuned
+            ],
+            outputs=gr_conversion_progress
+        ).then(
+            fn=update_interface,
+            inputs=None,
+            outputs=[gr_convert_btn, gr_ebook_file, gr_voice_file, gr_audio_player, gr_audiobooks_ddn, gr_modal_html]
+        )
+        interface.load(
+            fn=None,
+            js='''
+            () => {
+              const dataStr = window.localStorage.getItem('data');
+              if (dataStr) {
+                const obj = JSON.parse(dataStr);
+                obj.event = 'load';
+                console.log(obj);
+                return obj;
+              }
+              return null;
+            }
+            ''',
+            outputs=gr_read_data
+        )
+
+    try:
+        interface.queue(default_concurrency_limit=interface_concurrency_limit).launch(server_name=interface_host, server_port=interface_port, share=is_gui_shared)
+    except OSError as e:
+        print(f'Connection error: {e}')
+    except socket.error as e:
+        print(f'Socket error: {e}')
+    except KeyboardInterrupt:
+        print('Server interrupted by user. Shutting down...')
+    except Exception as e:
+        print(f'An unexpected error occurred: {e}')

lib/tokenizer.py

@@ -0,0 +1,906 @@
+import logging
+import os
+import re
+import textwrap
+from functools import cached_property
+
+import torch
+from num2words import num2words
+from spacy.lang.ar import Arabic
+from spacy.lang.en import English
+from spacy.lang.es import Spanish
+from spacy.lang.hi import Hindi
+from spacy.lang.ja import Japanese
+from spacy.lang.zh import Chinese
+from tokenizers import Tokenizer
+
+from TTS.tts.layers.xtts.zh_num2words import TextNorm as zh_num2words
+
+logger = logging.getLogger(__name__)
+
+
+def get_spacy_lang(lang):
+    """Return Spacy language used for sentence splitting."""
+    if lang == "zh":
+        return Chinese()
+    elif lang == "ja":
+        return Japanese()
+    elif lang == "ar":
+        return Arabic()
+    elif lang == "es":
+        return Spanish()
+    elif lang == "hi":
+        return Hindi()
+    else:
+        # For most languages, English does the job
+        return English()
+
+
+def split_sentence(text, lang, text_split_length=250):
+    """Preprocess the input text"""
+    text_splits = []
+    if text_split_length is not None and len(text) >= text_split_length:
+        text_splits.append("")
+        nlp = get_spacy_lang(lang)
+        nlp.add_pipe("sentencizer")
+        doc = nlp(text)
+        for sentence in doc.sents:
+            if len(text_splits[-1]) + len(str(sentence)) <= text_split_length:
+                # if the last sentence + the current sentence is less than the text_split_length
+                # then add the current sentence to the last sentence
+                text_splits[-1] += " " + str(sentence)
+                text_splits[-1] = text_splits[-1].lstrip()
+            elif len(str(sentence)) > text_split_length:
+                # if the current sentence is greater than the text_split_length
+                for line in textwrap.wrap(
+                    str(sentence),
+                    width=text_split_length,
+                    drop_whitespace=True,
+                    break_on_hyphens=False,
+                    tabsize=1,
+                ):
+                    text_splits.append(str(line))
+            else:
+                text_splits.append(str(sentence))
+
+        if len(text_splits) > 1:
+            if text_splits[0] == "":
+                del text_splits[0]
+    else:
+        text_splits = [text.lstrip()]
+
+    return text_splits
+
+
+_whitespace_re = re.compile(r"\s+")
+
+# List of (regular expression, replacement) pairs for abbreviations:
+_abbreviations = {
+    "en": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("mrs", "misess"),
+            ("mr", "mister"),
+            ("dr", "doctor"),
+            ("st", "saint"),
+            ("co", "company"),
+            ("jr", "junior"),
+            ("maj", "major"),
+            ("gen", "general"),
+            ("drs", "doctors"),
+            ("rev", "reverend"),
+            ("lt", "lieutenant"),
+            ("hon", "honorable"),
+            ("sgt", "sergeant"),
+            ("capt", "captain"),
+            ("esq", "esquire"),
+            ("ltd", "limited"),
+            ("col", "colonel"),
+            ("ft", "fort"),
+        ]
+    ],
+    "es": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("sra", "señora"),
+            ("sr", "señor"),
+            ("dr", "doctor"),
+            ("dra", "doctora"),
+            ("st", "santo"),
+            ("co", "compañía"),
+            ("jr", "junior"),
+            ("ltd", "limitada"),
+        ]
+    ],
+    "fr": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("mme", "madame"),
+            ("mr", "monsieur"),
+            ("dr", "docteur"),
+            ("st", "saint"),
+            ("co", "compagnie"),
+            ("jr", "junior"),
+            ("ltd", "limitée"),
+        ]
+    ],
+    "de": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("fr", "frau"),
+            ("dr", "doktor"),
+            ("st", "sankt"),
+            ("co", "firma"),
+            ("jr", "junior"),
+        ]
+    ],
+    "pt": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("sra", "senhora"),
+            ("sr", "senhor"),
+            ("dr", "doutor"),
+            ("dra", "doutora"),
+            ("st", "santo"),
+            ("co", "companhia"),
+            ("jr", "júnior"),
+            ("ltd", "limitada"),
+        ]
+    ],
+    "it": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            # ("sig.ra", "signora"),
+            ("sig", "signore"),
+            ("dr", "dottore"),
+            ("st", "santo"),
+            ("co", "compagnia"),
+            ("jr", "junior"),
+            ("ltd", "limitata"),
+        ]
+    ],
+    "pl": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("p", "pani"),
+            ("m", "pan"),
+            ("dr", "doktor"),
+            ("sw", "święty"),
+            ("jr", "junior"),
+        ]
+    ],
+    "ar": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            # There are not many common abbreviations in Arabic as in English.
+        ]
+    ],
+    "zh": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            # Chinese doesn't typically use abbreviations in the same way as Latin-based scripts.
+        ]
+    ],
+    "cs": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("dr", "doktor"),  # doctor
+            ("ing", "inženýr"),  # engineer
+            ("p", "pan"),  # Could also map to pani for woman but no easy way to do it
+            # Other abbreviations would be specialized and not as common.
+        ]
+    ],
+    "ru": [
+        (re.compile("\\b%s\\b" % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("г-жа", "госпожа"),  # Mrs.
+            ("г-н", "господин"),  # Mr.
+            ("д-р", "доктор"),  # doctor
+            # Other abbreviations are less common or specialized.
+        ]
+    ],
+    "nl": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("dhr", "de heer"),  # Mr.
+            ("mevr", "mevrouw"),  # Mrs.
+            ("dr", "dokter"),  # doctor
+            ("jhr", "jonkheer"),  # young lord or nobleman
+            # Dutch uses more abbreviations, but these are the most common ones.
+        ]
+    ],
+    "tr": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("b", "bay"),  # Mr.
+            ("byk", "büyük"),  # büyük
+            ("dr", "doktor"),  # doctor
+            # Add other Turkish abbreviations here if needed.
+        ]
+    ],
+    "hu": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("dr", "doktor"),  # doctor
+            ("b", "bácsi"),  # Mr.
+            ("nőv", "nővér"),  # nurse
+            # Add other Hungarian abbreviations here if needed.
+        ]
+    ],
+    "ko": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            # Korean doesn't typically use abbreviations in the same way as Latin-based scripts.
+        ]
+    ],
+    "hi": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            # Hindi doesn't typically use abbreviations in the same way as Latin-based scripts.
+        ]
+
+    ],
+    "vi": [
+        (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+        for x in [
+            ("ông", "ông"),  # Mr.
+            ("bà", "bà"),    # Mrs.
+            ("dr", "bác sĩ"), # doctor
+            ("ts", "tiến sĩ"), # PhD
+            ("st", "số thứ tự"), # ordinal
+        ]
+    ],
+}
+
+
+def expand_abbreviations_multilingual(text, lang="en"):
+    for regex, replacement in _abbreviations[lang]:
+        text = re.sub(regex, replacement, text)
+    return text
+
+
+_symbols_multilingual = {
+    "en": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " and "),
+            ("@", " at "),
+            ("%", " percent "),
+            ("#", " hash "),
+            ("$", " dollar "),
+            ("£", " pound "),
+            ("°", " degree "),
+        ]
+    ],
+    "es": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " y "),
+            ("@", " arroba "),
+            ("%", " por ciento "),
+            ("#", " numeral "),
+            ("$", " dolar "),
+            ("£", " libra "),
+            ("°", " grados "),
+        ]
+    ],
+    "fr": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " et "),
+            ("@", " arobase "),
+            ("%", " pour cent "),
+            ("#", " dièse "),
+            ("$", " dollar "),
+            ("£", " livre "),
+            ("°", " degrés "),
+        ]
+    ],
+    "de": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " und "),
+            ("@", " at "),
+            ("%", " prozent "),
+            ("#", " raute "),
+            ("$", " dollar "),
+            ("£", " pfund "),
+            ("°", " grad "),
+        ]
+    ],
+    "pt": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " e "),
+            ("@", " arroba "),
+            ("%", " por cento "),
+            ("#", " cardinal "),
+            ("$", " dólar "),
+            ("£", " libra "),
+            ("°", " graus "),
+        ]
+    ],
+    "it": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " e "),
+            ("@", " chiocciola "),
+            ("%", " per cento "),
+            ("#", " cancelletto "),
+            ("$", " dollaro "),
+            ("£", " sterlina "),
+            ("��", " gradi "),
+        ]
+    ],
+    "pl": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " i "),
+            ("@", " małpa "),
+            ("%", " procent "),
+            ("#", " krzyżyk "),
+            ("$", " dolar "),
+            ("£", " funt "),
+            ("°", " stopnie "),
+        ]
+    ],
+    "ar": [
+        # Arabic
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " و "),
+            ("@", " على "),
+            ("%", " في المئة "),
+            ("#", " رقم "),
+            ("$", " دولار "),
+            ("£", " جنيه "),
+            ("°", " درجة "),
+        ]
+    ],
+    "zh": [
+        # Chinese
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " 和 "),
+            ("@", " 在 "),
+            ("%", " 百分之 "),
+            ("#", " 号 "),
+            ("$", " 美元 "),
+            ("£", " 英镑 "),
+            ("°", " 度 "),
+        ]
+    ],
+    "cs": [
+        # Czech
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " a "),
+            ("@", " na "),
+            ("%", " procento "),
+            ("#", " křížek "),
+            ("$", " dolar "),
+            ("£", " libra "),
+            ("°", " stupně "),
+        ]
+    ],
+    "ru": [
+        # Russian
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " и "),
+            ("@", " собака "),
+            ("%", " процентов "),
+            ("#", " номер "),
+            ("$", " доллар "),
+            ("£", " фунт "),
+            ("°", " градус "),
+        ]
+    ],
+    "nl": [
+        # Dutch
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " en "),
+            ("@", " bij "),
+            ("%", " procent "),
+            ("#", " hekje "),
+            ("$", " dollar "),
+            ("£", " pond "),
+            ("°", " graden "),
+        ]
+    ],
+    "tr": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " ve "),
+            ("@", " at "),
+            ("%", " yüzde "),
+            ("#", " diyez "),
+            ("$", " dolar "),
+            ("£", " sterlin "),
+            ("°", " derece "),
+        ]
+    ],
+    "hu": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " és "),
+            ("@", " kukac "),
+            ("%", " százalék "),
+            ("#", " kettőskereszt "),
+            ("$", " dollár "),
+            ("£", " font "),
+            ("°", " fok "),
+        ]
+    ],
+    "ko": [
+        # Korean
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " 그리고 "),
+            ("@", " 에 "),
+            ("%", " 퍼센트 "),
+            ("#", " 번호 "),
+            ("$", " 달러 "),
+            ("£", " 파운드 "),
+            ("°", " 도 "),
+        ]
+    ],
+    "hi": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " और "),
+            ("@", " ऐट दी रेट "),
+            ("%", " प्रतिशत "),
+            ("#", " हैश "),
+            ("$", " डॉलर "),
+            ("£", " पाउंड "),
+            ("°", " डिग्री "),
+        ]
+    ],
+    "vi": [
+        (re.compile(r"%s" % re.escape(x[0]), re.IGNORECASE), x[1])
+        for x in [
+            ("&", " và "),        # and
+            ("@", " a còng "),    # at
+            ("%", " phần trăm "), # percent
+            ("#", " dấu thăng "), # hash
+            ("$", " đô la "),     # dollar
+            ("£", " bảng Anh "),  # pound
+            ("°", " độ "),        # degree
+        ]
+    ],
+}
+
+
+def expand_symbols_multilingual(text, lang="en"):
+    for regex, replacement in _symbols_multilingual[lang]:
+        text = re.sub(regex, replacement, text)
+        text = text.replace("  ", " ")  # Ensure there are no double spaces
+    return text.strip()
+
+
+_ordinal_re = {
+    "en": re.compile(r"([0-9]+)(st|nd|rd|th)"),
+    "es": re.compile(r"([0-9]+)(º|ª|er|o|a|os|as)"),
+    "fr": re.compile(r"([0-9]+)(º|ª|er|re|e|ème)"),
+    "de": re.compile(r"([0-9]+)(st|nd|rd|th|º|ª|\.(?=\s|$))"),
+    "pt": re.compile(r"([0-9]+)(º|ª|o|a|os|as)"),
+    "it": re.compile(r"([0-9]+)(º|°|ª|o|a|i|e)"),
+    "pl": re.compile(r"([0-9]+)(º|ª|st|nd|rd|th)"),
+    "ar": re.compile(r"([0-9]+)(ون|ين|ث|ر|ى)"),
+    "cs": re.compile(r"([0-9]+)\.(?=\s|$)"),  # In Czech, a dot is often used after the number to indicate ordinals.
+    "ru": re.compile(r"([0-9]+)(-й|-я|-е|-ое|-ье|-го)"),
+    "nl": re.compile(r"([0-9]+)(de|ste|e)"),
+    "tr": re.compile(r"([0-9]+)(\.|inci|nci|uncu|üncü|\.)"),
+    "hu": re.compile(r"([0-9]+)(\.|adik|edik|odik|edik|ödik|ödike|ik)"),
+    "ko": re.compile(r"([0-9]+)(번째|번|차|째)"),
+    "hi": re.compile(r"([0-9]+)(st|nd|rd|th)"),  # To check
+    "vi": re.compile(r"([0-9]+)(th|thứ)?"),  # Matches "1", "thứ 1", "2", "thứ 2"
+}
+_number_re = re.compile(r"[0-9]+")
+_currency_re = {
+    "USD": re.compile(r"((\$[0-9\.\,]*[0-9]+)|([0-9\.\,]*[0-9]+\$))"),
+    "GBP": re.compile(r"((£[0-9\.\,]*[0-9]+)|([0-9\.\,]*[0-9]+£))"),
+    "EUR": re.compile(r"(([0-9\.\,]*[0-9]+€)|((€[0-9\.\,]*[0-9]+)))"),
+}
+
+_comma_number_re = re.compile(r"\b\d{1,3}(,\d{3})*(\.\d+)?\b")
+_dot_number_re = re.compile(r"\b\d{1,3}(.\d{3})*(\,\d+)?\b")
+_decimal_number_re = re.compile(r"([0-9]+[.,][0-9]+)")
+
+
+def _remove_commas(m):
+    text = m.group(0)
+    if "," in text:
+        text = text.replace(",", "")
+    return text
+
+
+def _remove_dots(m):
+    text = m.group(0)
+    if "." in text:
+        text = text.replace(".", "")
+    return text
+
+
+def _expand_decimal_point(m, lang="en"):
+    amount = m.group(1).replace(",", ".")
+    return num2words(float(amount), lang=lang if lang != "cs" else "cz")
+
+
+def _expand_currency(m, lang="en", currency="USD"):
+    amount = float((re.sub(r"[^\d.]", "", m.group(0).replace(",", "."))))
+    full_amount = num2words(amount, to="currency", currency=currency, lang=lang if lang != "cs" else "cz")
+
+    and_equivalents = {
+        "en": ", ",
+        "es": " con ",
+        "fr": " et ",
+        "de": " und ",
+        "pt": " e ",
+        "it": " e ",
+        "pl": ", ",
+        "cs": ", ",
+        "ru": ", ",
+        "nl": ", ",
+        "ar": ", ",
+        "tr": ", ",
+        "hu": ", ",
+        "ko": ", ",
+        "hi": ", ",
+    }
+
+    if amount.is_integer():
+        last_and = full_amount.rfind(and_equivalents[lang])
+        if last_and != -1:
+            full_amount = full_amount[:last_and]
+
+    return full_amount
+
+
+def _expand_ordinal(m, lang="en"):
+    return num2words(int(m.group(1)), ordinal=True, lang=lang if lang != "cs" else "cz")
+
+
+def _expand_number(m, lang="en"):
+    return num2words(int(m.group(0)), lang=lang if lang != "cs" else "cz")
+
+
+def expand_numbers_multilingual(text, lang="en"):
+    if lang == "zh":
+        text = zh_num2words()(text)
+    else:
+        if lang in ["en", "ru"]:
+            text = re.sub(_comma_number_re, _remove_commas, text)
+        else:
+            text = re.sub(_dot_number_re, _remove_dots, text)
+        try:
+            text = re.sub(_currency_re["GBP"], lambda m: _expand_currency(m, lang, "GBP"), text)
+            text = re.sub(_currency_re["USD"], lambda m: _expand_currency(m, lang, "USD"), text)
+            text = re.sub(_currency_re["EUR"], lambda m: _expand_currency(m, lang, "EUR"), text)
+        except:
+            pass
+        if lang != "tr":
+            text = re.sub(_decimal_number_re, lambda m: _expand_decimal_point(m, lang), text)
+        text = re.sub(_ordinal_re[lang], lambda m: _expand_ordinal(m, lang), text)
+        text = re.sub(_number_re, lambda m: _expand_number(m, lang), text)
+    return text
+
+
+def lowercase(text):
+    return text.lower()
+
+
+def collapse_whitespace(text):
+    return re.sub(_whitespace_re, " ", text)
+
+
+def multilingual_cleaners(text, lang):
+    text = text.replace('"', "")
+    if lang == "tr":
+        text = text.replace("İ", "i")
+        text = text.replace("Ö", "ö")
+        text = text.replace("Ü", "ü")
+    text = lowercase(text)
+    text = expand_numbers_multilingual(text, lang)
+    text = expand_abbreviations_multilingual(text, lang)
+    text = expand_symbols_multilingual(text, lang=lang)
+    text = collapse_whitespace(text)
+    return text
+
+
+def basic_cleaners(text):
+    """Basic pipeline that lowercases and collapses whitespace without transliteration."""
+    text = lowercase(text)
+    text = collapse_whitespace(text)
+    return text
+
+
+def chinese_transliterate(text):
+    try:
+        import pypinyin
+    except ImportError as e:
+        raise ImportError("Chinese requires: pypinyin") from e
+    return "".join(
+        [p[0] for p in pypinyin.pinyin(text, style=pypinyin.Style.TONE3, heteronym=False, neutral_tone_with_five=True)]
+    )
+
+
+def japanese_cleaners(text, katsu):
+    text = katsu.romaji(text)
+    text = lowercase(text)
+    return text
+
+
+def korean_transliterate(text):
+    try:
+        from hangul_romanize import Transliter
+        from hangul_romanize.rule import academic
+    except ImportError as e:
+        raise ImportError("Korean requires: hangul_romanize") from e
+    r = Transliter(academic)
+    return r.translit(text)
+
+
+DEFAULT_VOCAB_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../data/tokenizer.json")
+
+
+class VoiceBpeTokenizer:
+    def __init__(self, vocab_file=None):
+        self.tokenizer = None
+        if vocab_file is not None:
+            self.tokenizer = Tokenizer.from_file(vocab_file)
+        self.char_limits = {
+            "en": 250,
+            "de": 253,
+            "fr": 273,
+            "es": 239,
+            "it": 213,
+            "pt": 203,
+            "pl": 224,
+            "zh": 82,
+            "ar": 166,
+            "cs": 186,
+            "ru": 182,
+            "nl": 251,
+            "tr": 226,
+            "ja": 71,
+            "hu": 224,
+            "ko": 95,
+            "hi": 150,
+            "vi": 250,
+        }
+
+    @cached_property
+    def katsu(self):
+        import cutlet
+
+        return cutlet.Cutlet()
+
+    def check_input_length(self, txt, lang):
+        lang = lang.split("-")[0]  # remove the region
+        limit = self.char_limits.get(lang, 250)
+        if len(txt) > limit:
+            logger.warning(
+                "The text length exceeds the character limit of %d for language '%s', this might cause truncated audio.",
+                limit,
+                lang,
+            )
+
+    def preprocess_text(self, txt, lang):
+        if lang in {"ar", "cs", "de", "en", "es", "fr", "hi", "hu", "it", "nl", "pl", "pt", "ru", "tr", "zh", "ko", "vi"}:
+            txt = multilingual_cleaners(txt, lang)
+            if lang == "zh":
+                txt = chinese_transliterate(txt)
+            if lang == "ko":
+                txt = korean_transliterate(txt)
+        elif lang == "ja":
+            txt = japanese_cleaners(txt, self.katsu)
+        else:
+            raise NotImplementedError(f"Language '{lang}' is not supported.")
+        return txt
+
+    def encode(self, txt, lang):
+        lang = lang.split("-")[0]  # remove the region
+        self.check_input_length(txt, lang)
+        txt = self.preprocess_text(txt, lang)
+        lang = "zh-cn" if lang == "zh" else lang
+        txt = f"[{lang}]{txt}"
+        txt = txt.replace(" ", "[SPACE]")
+        return self.tokenizer.encode(txt).ids
+
+    def decode(self, seq):
+        if isinstance(seq, torch.Tensor):
+            seq = seq.cpu().numpy()
+        txt = self.tokenizer.decode(seq, skip_special_tokens=False).replace(" ", "")
+        txt = txt.replace("[SPACE]", " ")
+        txt = txt.replace("[STOP]", "")
+        txt = txt.replace("[UNK]", "")
+        return txt
+
+    def __len__(self):
+        return self.tokenizer.get_vocab_size()
+
+    def get_number_tokens(self):
+        return max(self.tokenizer.get_vocab().values()) + 1
+
+
+def test_expand_numbers_multilingual():
+    test_cases = [
+        # English
+        ("In 12.5 seconds.", "In twelve point five seconds.", "en"),
+        ("There were 50 soldiers.", "There were fifty soldiers.", "en"),
+        ("This is a 1st test", "This is a first test", "en"),
+        ("That will be $20 sir.", "That will be twenty dollars sir.", "en"),
+        ("That will be 20€ sir.", "That will be twenty euro sir.", "en"),
+        ("That will be 20.15€ sir.", "That will be twenty euro, fifteen cents sir.", "en"),
+        ("That's 100,000.5.", "That's one hundred thousand point five.", "en"),
+        # French
+        ("En 12,5 secondes.", "En douze virgule cinq secondes.", "fr"),
+        ("Il y avait 50 soldats.", "Il y avait cinquante soldats.", "fr"),
+        ("Ceci est un 1er test", "Ceci est un premier test", "fr"),
+        ("Cela vous fera $20 monsieur.", "Cela vous fera vingt dollars monsieur.", "fr"),
+        ("Cela vous fera 20€ monsieur.", "Cela vous fera vingt euros monsieur.", "fr"),
+        ("Cela vous fera 20,15€ monsieur.", "Cela vous fera vingt euros et quinze centimes monsieur.", "fr"),
+        ("Ce sera 100.000,5.", "Ce sera cent mille virgule cinq.", "fr"),
+        # German
+        ("In 12,5 Sekunden.", "In zwölf Komma fünf Sekunden.", "de"),
+        ("Es gab 50 Soldaten.", "Es gab fünfzig Soldaten.", "de"),
+        ("Dies ist ein 1. Test", "Dies ist ein erste Test", "de"),  # Issue with gender
+        ("Das macht $20 Herr.", "Das macht zwanzig Dollar Herr.", "de"),
+        ("Das macht 20€ Herr.", "Das macht zwanzig Euro Herr.", "de"),
+        ("Das macht 20,15€ Herr.", "Das macht zwanzig Euro und fünfzehn Cent Herr.", "de"),
+        # Spanish
+        ("En 12,5 segundos.", "En doce punto cinco segundos.", "es"),
+        ("Había 50 soldados.", "Había cincuenta soldados.", "es"),
+        ("Este es un 1er test", "Este es un primero test", "es"),
+        ("Eso le costará $20 señor.", "Eso le costará veinte dólares señor.", "es"),
+        ("Eso le costará 20€ señor.", "Eso le costará veinte euros señor.", "es"),
+        ("Eso le costará 20,15€ señor.", "Eso le costará veinte euros con quince céntimos señor.", "es"),
+        # Italian
+        ("In 12,5 secondi.", "In dodici virgola cinque secondi.", "it"),
+        ("C'erano 50 soldati.", "C'erano cinquanta soldati.", "it"),
+        ("Questo è un 1° test", "Questo è un primo test", "it"),
+        ("Ti costerà $20 signore.", "Ti costerà venti dollari signore.", "it"),
+        ("Ti costerà 20€ signore.", "Ti costerà venti euro signore.", "it"),
+        ("Ti costerà 20,15€ signore.", "Ti costerà venti euro e quindici centesimi signore.", "it"),
+        # Portuguese
+        ("Em 12,5 segundos.", "Em doze vírgula cinco segundos.", "pt"),
+        ("Havia 50 soldados.", "Havia cinquenta soldados.", "pt"),
+        ("Este é um 1º teste", "Este é um primeiro teste", "pt"),
+        ("Isso custará $20 senhor.", "Isso custará vinte dólares senhor.", "pt"),
+        ("Isso custará 20€ senhor.", "Isso custará vinte euros senhor.", "pt"),
+        (
+            "Isso custará 20,15€ senhor.",
+            "Isso custará vinte euros e quinze cêntimos senhor.",
+            "pt",
+        ),  # "cêntimos" should be "centavos" num2words issue
+        # Polish
+        ("W 12,5 sekundy.", "W dwanaście przecinek pięć sekundy.", "pl"),
+        ("Było 50 żołnierzy.", "Było pięćdziesiąt żołnierzy.", "pl"),
+        ("To będzie kosztować 20€ panie.", "To będzie kosztować dwadzieścia euro panie.", "pl"),
+        ("To będzie kosztować 20,15€ panie.", "To będzie kosztować dwadzieścia euro, piętnaście centów panie.", "pl"),
+        # Arabic
+        ("في الـ 12,5 ثانية.", "في الـ اثنا عشر  , خمسون ثانية.", "ar"),
+        ("كان هناك 50 جنديًا.", "كان هناك خمسون جنديًا.", "ar"),
+        # ("ستكون النتيجة $20 يا سيد.", 'ستكون النتيجة عشرون دولار يا سيد.', 'ar'), # $ and € are mising from num2words
+        # ("ستكون النتيجة 20€ يا سيد.", 'ستكون النتيجة عشرون يورو يا سيد.', 'ar'),
+        # Czech
+        ("Za 12,5 vteřiny.", "Za dvanáct celá pět vteřiny.", "cs"),
+        ("Bylo tam 50 vojáků.", "Bylo tam padesát vojáků.", "cs"),
+        ("To bude stát 20€ pane.", "To bude stát dvacet euro pane.", "cs"),
+        ("To bude 20.15€ pane.", "To bude dvacet euro, patnáct centů pane.", "cs"),
+        # Russian
+        ("Через 12.5 секунды.", "Через двенадцать запятая пять секунды.", "ru"),
+        ("Там было 50 солдат.", "Там было пятьдесят солдат.", "ru"),
+        ("Это будет 20.15€ сэр.", "Это будет двадцать евро, пятнадцать центов сэр.", "ru"),
+        ("Это будет стоить 20€ господин.", "Это будет стоить двадцать евро господин.", "ru"),
+        # Dutch
+        ("In 12,5 seconden.", "In twaalf komma vijf seconden.", "nl"),
+        ("Er waren 50 soldaten.", "Er waren vijftig soldaten.", "nl"),
+        ("Dat wordt dan $20 meneer.", "Dat wordt dan twintig dollar meneer.", "nl"),
+        ("Dat wordt dan 20€ meneer.", "Dat wordt dan twintig euro meneer.", "nl"),
+        # Chinese (Simplified)
+        ("在12.5秒内", "在十二点五秒内", "zh"),
+        ("有50名士兵", "有五十名士兵", "zh"),
+        # ("那将是$20先生", '那将是二十美元先生', 'zh'), currency doesn't work
+        # ("那将是20€先生", '那将是二十欧元先生', 'zh'),
+        # Turkish
+        # ("12,5 saniye içinde.", 'On iki virgül beş saniye içinde.', 'tr'), # decimal doesn't work for TR
+        ("50 asker vardı.", "elli asker vardı.", "tr"),
+        ("Bu 1. test", "Bu birinci test", "tr"),
+        # ("Bu 100.000,5.", 'Bu yüz bin virgül beş.', 'tr'),
+        # Hungarian
+        ("12,5 másodperc alatt.", "tizenkettő egész öt tized másodperc alatt.", "hu"),
+        ("50 katona volt.", "ötven katona volt.", "hu"),
+        ("Ez az 1. teszt", "Ez az első teszt", "hu"),
+        # Korean
+        ("12.5 초 안에.", "십이 점 다섯 초 안에.", "ko"),
+        ("50 명의 병사가 있었다.", "오십 명의 병사가 있었다.", "ko"),
+        ("이것은 1 번째 테스트입니다", "이것은 첫 번째 테스트입니다", "ko"),
+        # Hindi
+        ("12.5 सेकंड में।", "साढ़े बारह सेकंड में।", "hi"),
+        ("50 सैनिक थे।", "पचास सैनिक थे।", "hi"),
+    ]
+    for a, b, lang in test_cases:
+        out = expand_numbers_multilingual(a, lang=lang)
+        assert out == b, f"'{out}' vs '{b}'"
+
+
+def test_abbreviations_multilingual():
+    test_cases = [
+        # English
+        ("Hello Mr. Smith.", "Hello mister Smith.", "en"),
+        ("Dr. Jones is here.", "doctor Jones is here.", "en"),
+        # Spanish
+        ("Hola Sr. Garcia.", "Hola señor Garcia.", "es"),
+        ("La Dra. Martinez es muy buena.", "La doctora Martinez es muy buena.", "es"),
+        # French
+        ("Bonjour Mr. Dupond.", "Bonjour monsieur Dupond.", "fr"),
+        ("Mme. Moreau est absente aujourd'hui.", "madame Moreau est absente aujourd'hui.", "fr"),
+        # German
+        ("Frau Dr. Müller ist sehr klug.", "Frau doktor Müller ist sehr klug.", "de"),
+        # Portuguese
+        ("Olá Sr. Silva.", "Olá senhor Silva.", "pt"),
+        ("Dra. Costa, você está disponível?", "doutora Costa, você está disponível?", "pt"),
+        # Italian
+        ("Buongiorno, Sig. Rossi.", "Buongiorno, signore Rossi.", "it"),
+        # ("Sig.ra Bianchi, posso aiutarti?", 'signora Bianchi, posso aiutarti?', 'it'), # Issue with matching that pattern
+        # Polish
+        ("Dzień dobry, P. Kowalski.", "Dzień dobry, pani Kowalski.", "pl"),
+        ("M. Nowak, czy mogę zadać pytanie?", "pan Nowak, czy mogę zadać pytanie?", "pl"),
+        # Czech
+        ("P. Novák", "pan Novák", "cs"),
+        ("Dr. Vojtěch", "doktor Vojtěch", "cs"),
+        # Dutch
+        ("Dhr. Jansen", "de heer Jansen", "nl"),
+        ("Mevr. de Vries", "mevrouw de Vries", "nl"),
+        # Russian
+        ("Здравствуйте Г-н Иванов.", "Здравствуйте господин Иванов.", "ru"),
+        ("Д-р Смирнов здесь, чтобы увидеть вас.", "доктор Смирнов здесь, чтобы увидеть вас.", "ru"),
+        # Turkish
+        ("Merhaba B. Yılmaz.", "Merhaba bay Yılmaz.", "tr"),
+        ("Dr. Ayşe burada.", "doktor Ayşe burada.", "tr"),
+        # Hungarian
+        ("Dr. Szabó itt van.", "doktor Szabó itt van.", "hu"),
+    ]
+
+    for a, b, lang in test_cases:
+        out = expand_abbreviations_multilingual(a, lang=lang)
+        assert out == b, f"'{out}' vs '{b}'"
+
+
+def test_symbols_multilingual():
+    test_cases = [
+        ("I have 14% battery", "I have 14 percent battery", "en"),
+        ("Te veo @ la fiesta", "Te veo arroba la fiesta", "es"),
+        ("J'ai 14° de fièvre", "J'ai 14 degrés de fièvre", "fr"),
+        ("Die Rechnung beträgt £ 20", "Die Rechnung beträgt pfund 20", "de"),
+        ("O meu email é ana&joao@gmail.com", "O meu email é ana e joao arroba gmail.com", "pt"),
+        ("linguaggio di programmazione C#", "linguaggio di programmazione C cancelletto", "it"),
+        ("Moja temperatura to 36.6°", "Moja temperatura to 36.6 stopnie", "pl"),
+        ("Mám 14% baterie", "Mám 14 procento baterie", "cs"),
+        ("Těším se na tebe @ party", "Těším se na tebe na party", "cs"),
+        ("У меня 14% заряда", "У меня 14 процентов заряда", "ru"),
+        ("Я буду @ дома", "Я буду собака дома", "ru"),
+        ("Ik heb 14% batterij", "Ik heb 14 procent batterij", "nl"),
+        ("Ik zie je @ het feest", "Ik zie je bij het feest", "nl"),
+        ("لدي 14% في البطارية", "لدي 14 في المئة في البطارية", "ar"),
+        ("我的电量为 14%", "我的电量为 14 百分之", "zh"),
+        ("Pilim %14 dolu.", "Pilim yüzde 14 dolu.", "tr"),
+        ("Az akkumulátorom töltöttsége 14%", "Az akkumulátorom töltöttsége 14 százalék", "hu"),
+        ("배터리 잔량이 14%입니다.", "배터리 잔량이 14 퍼센트입니다.", "ko"),
+        ("मेरे पास 14% बैटरी है।", "मेरे पास चौदह प्रतिशत बैटरी है।", "hi"),
+    ]
+
+    for a, b, lang in test_cases:
+        out = expand_symbols_multilingual(a, lang=lang)
+        assert out == b, f"'{out}' vs '{b}'"
+
+
+if __name__ == "__main__":
+    test_expand_numbers_multilingual()
+    test_abbreviations_multilingual()
+    test_symbols_multilingual()
+