v2.0 will add the voices folder in a sec

Audiobooks/mini_story - Drew.m4b

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b37c09b708bd87441d04d285e07dfa8bcd11b3d4b50e18065c29ee62c323db10
-size 4961567

Base_XTTS_Model/tts_models--multilingual--multi-dataset--xtts_v2/config.json

@@ -1,159 +0,0 @@
-{
-    "output_path": "output",
-    "logger_uri": null,
-    "run_name": "run",
-    "project_name": null,
-    "run_description": "\ud83d\udc38Coqui trainer run.",
-    "print_step": 25,
-    "plot_step": 100,
-    "model_param_stats": false,
-    "wandb_entity": null,
-    "dashboard_logger": "tensorboard",
-    "save_on_interrupt": true,
-    "log_model_step": null,
-    "save_step": 10000,
-    "save_n_checkpoints": 5,
-    "save_checkpoints": true,
-    "save_all_best": false,
-    "save_best_after": 10000,
-    "target_loss": null,
-    "print_eval": false,
-    "test_delay_epochs": 0,
-    "run_eval": true,
-    "run_eval_steps": null,
-    "distributed_backend": "nccl",
-    "distributed_url": "tcp://localhost:54321",
-    "mixed_precision": false,
-    "precision": "fp16",
-    "epochs": 1000,
-    "batch_size": 32,
-    "eval_batch_size": 16,
-    "grad_clip": 0.0,
-    "scheduler_after_epoch": true,
-    "lr": 0.001,
-    "optimizer": "radam",
-    "optimizer_params": null,
-    "lr_scheduler": null,
-    "lr_scheduler_params": {},
-    "use_grad_scaler": false,
-    "allow_tf32": false,
-    "cudnn_enable": true,
-    "cudnn_deterministic": false,
-    "cudnn_benchmark": false,
-    "training_seed": 54321,
-    "model": "xtts",
-    "num_loader_workers": 0,
-    "num_eval_loader_workers": 0,
-    "use_noise_augment": false,
-    "audio": {
-        "sample_rate": 22050,
-        "output_sample_rate": 24000
-    },
-    "use_phonemes": false,
-    "phonemizer": null,
-    "phoneme_language": null,
-    "compute_input_seq_cache": false,
-    "text_cleaner": null,
-    "enable_eos_bos_chars": false,
-    "test_sentences_file": "",
-    "phoneme_cache_path": null,
-    "characters": null,
-    "add_blank": false,
-    "batch_group_size": 0,
-    "loss_masking": null,
-    "min_audio_len": 1,
-    "max_audio_len": Infinity,
-    "min_text_len": 1,
-    "max_text_len": Infinity,
-    "compute_f0": false,
-    "compute_energy": false,
-    "compute_linear_spec": false,
-    "precompute_num_workers": 0,
-    "start_by_longest": false,
-    "shuffle": false,
-    "drop_last": false,
-    "datasets": [
-        {
-            "formatter": "",
-            "dataset_name": "",
-            "path": "",
-            "meta_file_train": "",
-            "ignored_speakers": null,
-            "language": "",
-            "phonemizer": "",
-            "meta_file_val": "",
-            "meta_file_attn_mask": ""
-        }
-    ],
-    "test_sentences": [],
-    "eval_split_max_size": null,
-    "eval_split_size": 0.01,
-    "use_speaker_weighted_sampler": false,
-    "speaker_weighted_sampler_alpha": 1.0,
-    "use_language_weighted_sampler": false,
-    "language_weighted_sampler_alpha": 1.0,
-    "use_length_weighted_sampler": false,
-    "length_weighted_sampler_alpha": 1.0,
-    "model_args": {
-        "gpt_batch_size": 1,
-        "enable_redaction": false,
-        "kv_cache": true,
-        "gpt_checkpoint": null,
-        "clvp_checkpoint": null,
-        "decoder_checkpoint": null,
-        "num_chars": 255,
-        "tokenizer_file": "",
-        "gpt_max_audio_tokens": 605,
-        "gpt_max_text_tokens": 402,
-        "gpt_max_prompt_tokens": 70,
-        "gpt_layers": 30,
-        "gpt_n_model_channels": 1024,
-        "gpt_n_heads": 16,
-        "gpt_number_text_tokens": 6681,
-        "gpt_start_text_token": null,
-        "gpt_stop_text_token": null,
-        "gpt_num_audio_tokens": 1026,
-        "gpt_start_audio_token": 1024,
-        "gpt_stop_audio_token": 1025,
-        "gpt_code_stride_len": 1024,
-        "gpt_use_masking_gt_prompt_approach": true,
-        "gpt_use_perceiver_resampler": true,
-        "input_sample_rate": 22050,
-        "output_sample_rate": 24000,
-        "output_hop_length": 256,
-        "decoder_input_dim": 1024,
-        "d_vector_dim": 512,
-        "cond_d_vector_in_each_upsampling_layer": true,
-        "duration_const": 102400
-    },
-    "model_dir": null,
-    "languages": [
-        "en",
-        "es",
-        "fr",
-        "de",
-        "it",
-        "pt",
-        "pl",
-        "tr",
-        "ru",
-        "nl",
-        "cs",
-        "ar",
-        "zh-cn",
-        "hu",
-        "ko",
-        "ja",
-        "hi"
-    ],
-    "temperature": 0.75,
-    "length_penalty": 1.0,
-    "repetition_penalty": 5.0,
-    "top_k": 50,
-    "top_p": 0.85,
-    "num_gpt_outputs": 1,
-    "gpt_cond_len": 30,
-    "gpt_cond_chunk_len": 4,
-    "max_ref_len": 30,
-    "sound_norm_refs": false
-}

Base_XTTS_Model/tts_models--multilingual--multi-dataset--xtts_v2/hash.md5

@@ -1 +0,0 @@
-10f92b55c512af7a8d39d650547a15a7

Base_XTTS_Model/tts_models--multilingual--multi-dataset--xtts_v2/model.pth

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c7ea20001c6a0a841c77e252d8409f6a74fb423e79b3206a0771ba5989776187
-size 1867929118

Base_XTTS_Model/tts_models--multilingual--multi-dataset--xtts_v2/tos_agreed.txt

@@ -1 +0,0 @@
-I have read, understood and agreed to the Terms and Conditions.

README.md

@@ -1,185 +1,14 @@
 ---
-title: Ebook2audiobook
-emoji: 🐸📖
-colorFrom: red
-colorTo: yellow
+title: Ebook2audiobook V2.0 Beta
+emoji: 🚀
+colorFrom: indigo
+colorTo: red
 sdk: gradio
-sdk_version: 4.44.0
+sdk_version: 5.9.0
 app_file: app.py
 pinned: true
-license: mit
-short_description: Convert any Ebook to AudioBook with Xtts + VoiceCloning!
+license: apache-2.0
+short_description: Added improvements, 1107+ languages supported
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-
-
-
-
-
-# 📚 ebook2audiobookXTTS
-
-Convert eBooks to audiobooks with chapters and metadata using Calibre and Coqui XTTS. Supports optional voice cloning and multiple languages!
-
-## 🌟 Features
-
-- 📖 Converts eBooks to text format with Calibre.
-- 📚 Splits eBook into chapters for organized audio.
-- 🎙️ High-quality text-to-speech with Coqui XTTS.
-- 🗣️ Optional voice cloning with your own voice file.
-- 🌍 Supports multiple languages (English by default).
-- 🖥️ Designed to run on 4GB RAM.
-
-## 🛠️ Requirements
-
-- Python 3.x
-- `coqui-tts` Python package
-- Calibre (for eBook conversion)
-- FFmpeg (for audiobook creation)
-- Optional: Custom voice file for voice cloning
-
-### 🔧 Installation Instructions
-
-1. **Install Python 3.x** from [Python.org](https://www.python.org/downloads/).
-
-2. **Install Calibre**:
-   - **Ubuntu**: `sudo apt-get install -y calibre`
-   - **macOS**: `brew install calibre`
-   - **Windows** (Admin Powershell): `choco install calibre`
-
-3. **Install FFmpeg**:
-   - **Ubuntu**: `sudo apt-get install -y ffmpeg`
-   - **macOS**: `brew install ffmpeg`
-   - **Windows** (Admin Powershell): `choco install ffmpeg`
-
-4. **Optional: Install Mecab** (for non-Latin languages):
-   - **Ubuntu**: `sudo apt-get install -y mecab libmecab-dev mecab-ipadic-utf8`
-   - **macOS**: `brew install mecab`, `brew install mecab-ipadic`
-   - **Windows** (Admin Powershell): `choco install mecab` (Note: Japanese support is limited)
-
-5. **Install Python packages**:
-   ```bash
-   pip install tts==0.21.3 pydub nltk beautifulsoup4 ebooklib tqdm
-   ```
-
-   **For non-Latin languages**:
-   ```bash
-   python -m unidic download
-   pip install mecab mecab-python3 unidic
-   ```
-
-## 🌐 Supported 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)**
-
-Specify the language code when running the script.
-
-## 🚀 Usage
-
-### 🖥️ Gradio Web Interface
-
-1. **Run the Script**:
-   ```bash
-   python custom_model_ebook2audiobookXTTS_gradio.py
-   ```
-
-2. **Open the Web App**: Click the URL provided in the terminal to access the web app and convert eBooks.
-
-### 📝 Basic Usage
-
-```bash
-python ebook2audiobook.py <path_to_ebook_file> [path_to_voice_file] [language_code]
-```
-
-- **<path_to_ebook_file>**: Path to your eBook file.
-- **[path_to_voice_file]**: Optional for voice cloning.
-- **[language_code]**: Optional to specify language.
-
-### 🧩 Custom XTTS Model
-
-```bash
-python custom_model_ebook2audiobookXTTS.py <ebook_file_path> <target_voice_file_path> <language> <custom_model_path> <custom_config_path> <custom_vocab_path>
-```
-
-- **<ebook_file_path>**: Path to your eBook file.
-- **<target_voice_file_path>**: Optional for voice cloning.
-- **<language>**: Optional to specify language.
-- **<custom_model_path>**: Path to `model.pth`.
-- **<custom_config_path>**: Path to `config.json`.
-- **<custom_vocab_path>**: Path to `vocab.json`.
-
-### 🐳 Using Docker
-
-You can also use Docker to run the eBook to Audiobook converter. This method ensures consistency across different environments and simplifies setup.
-
-#### 🚀 Running the Docker Container
-
-To run the Docker container and start the Gradio interface, use the following command:
-
- -Run with CPU only
-```powershell
-docker run -it --rm -p 7860:7860 athomasson2/ebook2audiobookxtts:latest
-```
- -Run with GPU Speedup (Nvida graphics cards only)
-```powershell
-docker run -it --rm --gpus all -p 7860:7860 athomasson2/ebook2audiobookxtts:latest
-```
-
-This command will start the Gradio interface on port 7860.(localhost:7860)
-
-#### 🖥️ Docker GUI 
-
-<img width="1401" alt="Screenshot 2024-08-25 at 10 08 40 AM" src="https://github.com/user-attachments/assets/78cfd33e-cd46-41cc-8128-3820160a5e40">
-<img width="1406" alt="Screenshot 2024-08-25 at 10 08 51 AM" src="https://github.com/user-attachments/assets/dbfad9f6-e6e5-4cad-b248-adb76c5434f3">
-
-### 🛠️ For Custom Xtts Models
-
-Models built to be better at a specific voice. Check out my Hugging Face page [here](https://huggingface.co/drewThomasson).
-
-To use a custom model, paste the link of the `Finished_model_files.zip` file like this:
-
-[David Attenborough fine tuned Finished_model_files.zip](https://huggingface.co/drewThomasson/xtts_David_Attenborough_fine_tune/resolve/main/Finished_model_files.zip?download=true)
-
-
-
-
-More details can be found at the [Dockerfile Hub Page]([https://github.com/DrewThomasson/ebook2audiobookXTTS](https://hub.docker.com/repository/docker/athomasson2/ebook2audiobookxtts/general)).
-
-## 🌐 Fine Tuned Xtts models
-
-To find already fine-tuned XTTS models, visit [this Hugging Face link](https://huggingface.co/drewThomasson) 🌐. Search for models that include "xtts fine tune" in their names.
-
-## 🎥 Demos
-
-https://github.com/user-attachments/assets/8486603c-38b1-43ce-9639-73757dfb1031
-
-## 📚 Supported eBook Formats
-
-- `.epub`, `.pdf`, `.mobi`, `.txt`, `.html`, `.rtf`, `.chm`, `.lit`, `.pdb`, `.fb2`, `.odt`, `.cbr`, `.cbz`, `.prc`, `.lrf`, `.pml`, `.snb`, `.cbc`, `.rb`, `.tcr`
-- **Best results**: `.epub` or `.mobi` for automatic chapter detection
-
-## 📂 Output
-
-- Creates an `.m4b` file with metadata and chapters.
-- **Example Output**: ![Example](https://github.com/DrewThomasson/VoxNovel/blob/dc5197dff97252fa44c391dc0596902d71278a88/readme_files/example_in_app.jpeg)
-
-## 🙏 Special Thanks
-
-- **Coqui TTS**: [Coqui TTS GitHub](https://github.com/coqui-ai/TTS)
-- **Calibre**: [Calibre Website](https://calibre-ebook.com)
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,1052 +1,232 @@
-print("starting...")
-
 import argparse
-
-language_options = [
-    "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"
-]
-char_limits = {
-    "en": 250,      # English
-    "es": 239,      # Spanish
-    "fr": 273,      # French
-    "de": 253,      # German
-    "it": 213,      # Italian
-    "pt": 203,      # Portuguese
-    "pl": 224,      # Polish
-    "tr": 226,      # Turkish
-    "ru": 182,      # Russian
-    "nl": 251,      # Dutch
-    "cs": 186,      # Czech
-    "ar": 166,      # Arabic
-    "zh-cn": 82,    # Chinese (Simplified)
-    "ja": 71,       # Japanese
-    "hu": 224,      # Hungarian
-    "ko": 95,       # Korean
-}
-
-# Mapping of language codes to NLTK's supported language names
-language_mapping = {
-    "en": "english",
-    "de": "german",
-    "fr": "french",
-    "es": "spanish",
-    "it": "italian",
-    "pt": "portuguese",
-    "nl": "dutch",
-    "pl": "polish",  
-    "cs": "czech",   
-    "ru": "russian",
-    "tr": "turkish",
-    "el": "greek",
-    "et": "estonian",
-    "no": "norwegian",
-    "ml": "malayalam",
-    "sl": "slovene",
-    "da": "danish",
-    "fi": "finnish",
-    "sv": "swedish"
-}
-
-
-# Convert the list of languages to a string to display in the help text
-language_options_str = ", ".join(language_options)
-
-# Argument parser to handle optional parameters with descriptions
-parser = argparse.ArgumentParser(
-    description="Convert eBooks to Audiobooks using a Text-to-Speech model. You can either launch the Gradio interface or run the script in headless mode for direct conversion.",
-    epilog="Example: python script.py --headless --ebook path_to_ebook --voice path_to_voice --language en --use_custom_model True --custom_model model.pth --custom_config config.json --custom_vocab vocab.json"
-)
-parser.add_argument("--share", type=bool, default=False, help="Set to True to enable a public shareable Gradio link. Defaults to False.")
-parser.add_argument("--headless", type=bool, default=False, help="Set to True to run in headless mode without the Gradio interface. Defaults to False.")
-parser.add_argument("--ebook", type=str, help="Path to the ebook file for conversion. Required in headless mode.")
-parser.add_argument("--voice", type=str, help="Path to the target voice file for TTS. Optional, uses a default voice if not provided.")
-parser.add_argument("--language", type=str, default="en", 
-                    help=f"Language for the audiobook conversion. Options: {language_options_str}. Defaults to English (en).")
-parser.add_argument("--use_custom_model", type=bool, default=False, 
-                    help="Set to True to use a custom TTS model. Defaults to False. Must be True to use custom models, otherwise you'll get an error.")
-parser.add_argument("--custom_model", type=str, help="Path to the custom model file (.pth). Required if using a custom model.")
-parser.add_argument("--custom_config", type=str, help="Path to the custom config file (config.json). Required if using a custom model.")
-parser.add_argument("--custom_vocab", type=str, help="Path to the custom vocab file (vocab.json). Required if using a custom model.")
-parser.add_argument("--custom_model_url", type=str, 
-                    help=("URL to download the custom model as a zip file. Optional, but will be used if provided. "
-                          "Examples include David Attenborough's model: "
-                          "'https://huggingface.co/drewThomasson/xtts_David_Attenborough_fine_tune/resolve/main/Finished_model_files.zip?download=true'. "
-                          "More XTTS fine-tunes can be found on my Hugging Face at 'https://huggingface.co/drewThomasson'."))
-parser.add_argument("--temperature", type=float, default=0.65, help="Temperature for the model. Defaults to 0.65. Higher Tempatures will lead to more creative outputs IE: more Hallucinations. Lower Tempatures will be more monotone outputs IE: less Hallucinations.")
-parser.add_argument("--length_penalty", type=float, default=1.0, help="A length penalty applied to the autoregressive decoder. Defaults to 1.0.  Not applied to custom models.")
-parser.add_argument("--repetition_penalty", type=float, default=2.0, help="A penalty that prevents the autoregressive decoder from repeating itself. Defaults to 2.0.")
-parser.add_argument("--top_k", type=int, default=50, help="Top-k sampling. Lower values mean more likely outputs and increased audio generation speed. Defaults to 50.")
-parser.add_argument("--top_p", type=float, default=0.8, help="Top-p sampling. Lower values mean more likely outputs and increased audio generation speed. Defaults to 0.8.")
-parser.add_argument("--speed", type=float, default=1.0, help="Speed factor for the speech generation. IE: How fast the Narrerator will speak. Defaults to 1.0.")
-parser.add_argument("--enable_text_splitting", type=bool, default=False, help="Enable splitting text into sentences. Defaults to True.")
-
-args = parser.parse_args()
-
-
-
 import os
-import shutil
+import regex as re
+import socket
 import subprocess
-import re
-from pydub import AudioSegment
-import tempfile
-from pydub import AudioSegment
-import nltk
-from nltk.tokenize import sent_tokenize
 import sys
-import torch
-from TTS.api import TTS
-from TTS.tts.configs.xtts_config import XttsConfig
-from TTS.tts.models.xtts import Xtts
-from tqdm import tqdm
-import gradio as gr
-from gradio import Progress
-import urllib.request
-import zipfile
-import socket
-#import MeCab
-#import unidic
-
-#nltk.download('punkt_tab')
-
-# By using XTTS you agree to CPML license https://coqui.ai/cpml
-os.environ["COQUI_TOS_AGREED"] = "1"
-
-# Import the locally stored Xtts default model
-import import_locally_stored_tts_model_files
-
-#make the nltk folder point to the nltk folder in the app dir
-nltk.data.path.append('/home/user/app/nltk_data')
-
-# Download UniDic if it's not already installed
-#unidic.download()
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(f"Device selected is: {device}")
-
-#nltk.download('punkt')  # Make sure to download the necessary models
-
-
-def download_and_extract_zip(url, extract_to='.'):
-    try:
-        # Ensure the directory exists
-        os.makedirs(extract_to, exist_ok=True)
-        
-        zip_path = os.path.join(extract_to, 'model.zip')
-        
-        # Download with progress bar
-        with tqdm(unit='B', unit_scale=True, miniters=1, desc="Downloading Model") as t:
-            def reporthook(blocknum, blocksize, totalsize):
-                t.total = totalsize
-                t.update(blocknum * blocksize - t.n)
-
-            urllib.request.urlretrieve(url, zip_path, reporthook=reporthook)
-        print(f"Downloaded zip file to {zip_path}")
-        
-        # Unzipping with progress bar
-        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-            files = zip_ref.namelist()
-            with tqdm(total=len(files), unit="file", desc="Extracting Files") as t:
-                for file in files:
-                    if not file.endswith('/'):  # Skip directories
-                        # Extract the file to the temporary directory
-                        extracted_path = zip_ref.extract(file, extract_to)
-                        # Move the file to the base directory
-                        base_file_path = os.path.join(extract_to, os.path.basename(file))
-                        os.rename(extracted_path, base_file_path)
-                    t.update(1)
-        
-        # Cleanup: Remove the ZIP file and any empty folders
-        os.remove(zip_path)
-        for root, dirs, files in os.walk(extract_to, topdown=False):
-            for name in dirs:
-                os.rmdir(os.path.join(root, name))
-        print(f"Extracted files to {extract_to}")
-        
-        # Check if all required files are present
-        required_files = ['model.pth', 'config.json', 'vocab.json_']
-        missing_files = [file for file in required_files if not os.path.exists(os.path.join(extract_to, file))]
-        
-        if not missing_files:
-            print("All required files (model.pth, config.json, vocab.json_) found.")
-        else:
-            print(f"Missing files: {', '.join(missing_files)}")
-    
-    except Exception as e:
-        print(f"Failed to download or extract zip file: {e}")
-
-
-
-def is_folder_empty(folder_path):
-    if os.path.exists(folder_path) and os.path.isdir(folder_path):
-        # List directory contents
-        if not os.listdir(folder_path):
-            return True  # The folder is empty
-        else:
-            return False  # The folder is not empty
+import unidic
+
+from lib.conf import *
+from lib.lang import language_mapping, default_language_code
+
+def check_python_version():
+    current_version = sys.version_info[:2]  # (major, minor)
+    if current_version < min_python_version or current_version > max_python_version:
+        error = f'''********** Error: Your OS Python version is not compatible! (current: {current_version[0]}.{current_version[1]})
+        Please create a virtual python environment verrsion {min_python_version[0]}.{min_python_version[1]} or {max_python_version[0]}.{max_python_version[1]} 
+        with conda or python -v venv **********'''
+        print(error)
+        return False
     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):
+        return True
+        
+def check_and_install_requirements(file_path):
+    if not os.path.exists(file_path):
+        print(f'Warning: File {file_path} not found. Skipping package check.')
     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)
-
+        from importlib.metadata import version, PackageNotFoundError
+        with open(file_path, 'r') as f:
+            contents = f.read().replace('\r', '\n')
+            packages = [pkg.strip() for pkg in contents.splitlines() if pkg.strip()]
+
+        missing_packages = []
+        for package in packages:
+            # Extract package name without version specifier
+            pkg_name = re.split(r'[<>=]', package)[0].strip()
+            try:
+                installed_version = version(pkg_name)
+            except PackageNotFoundError:
+                print(f'{package} is missing.')
+                missing_packages.append(package)
+                pass
+
+        if missing_packages:
+            print('\nInstalling missing packages...')
+            try:
+                subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', 'pip'] + missing_packages)
+            except subprocess.CalledProcessError as e:
+                print(f'Failed to install packages: {e}')
+                return False
 
-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, batch_size=256):
-        # Initialize an empty audio segment
-        combined_audio = AudioSegment.empty()
-    
-        # 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:
-                audio_segment = AudioSegment.from_wav(chapter_file)
-                batch_audio += audio_segment
-    
-            # Combine the batch audio with the overall combined_audio
-            combined_audio += batch_audio
-    
-        # 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']
+        return True
+    except Exception as e:
+        raise(f'An error occurred: {e}')  
         
-        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 order 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
+def check_dictionary():
+    unidic_path = unidic.DICDIR
+    dicrc = os.path.join(unidic_path, 'dicrc')
+    if not os.path.exists(dicrc) or os.path.getsize(dicrc) == 0:
         try:
-            subprocess.run(['ebook-convert', input_path, output_path], check=True)
+            print('UniDic dictionary not found or incomplete. Downloading now...')
+            subprocess.run(['python', '-m', 'unidic', 'download'], 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
-
-default_target_voice_path = "default_voice.wav"  # Ensure this is a valid path
-default_language_code = "en"
-
-
-# Function to check if vocab.json exists and rename it
-def rename_vocab_file_if_exists(directory):
-    vocab_path = os.path.join(directory, 'vocab.json')
-    new_vocab_path = os.path.join(directory, 'vocab.json_')
-
-    # Check if vocab.json exists
-    if os.path.exists(vocab_path):
-        # Rename the file
-        os.rename(vocab_path, new_vocab_path)
-        print(f"Renamed {vocab_path} to {new_vocab_path}")
-        return True  # Return True if the file was found and renamed
-
-
-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)))
+            print(f'Failed to download UniDic dictionary. Error: {e}')
+            raise SystemExit('Unable to continue without UniDic. Exiting...')
+    return True
+
+def is_port_in_use(port):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(('0.0.0.0', port)) == 0
+
+def main():
+    global is_gui_process
+
+    # Convert the list of languages to a string to display in the help text
+    lang_list_str = ', '.join(list(language_mapping.keys()))
+
+    # Argument parser to handle optional parameters with descriptions
+    parser = argparse.ArgumentParser(
+        description='Convert eBooks to Audiobooks using a Text-to-Speech model. You can either launch the Gradio interface or run the script in headless mode for direct conversion.',
+        epilog='''
+Example usage:    
+Windows:
+    headless:
+    ebook2audiobook.cmd --headless --ebook 'path_to_ebook'
+    Graphic Interface:
+    ebook2audiobook.cmd
+Linux/Mac:
+    headless:
+    ./ebook2audiobook.sh --headless --ebook 'path_to_ebook'
+    Graphic Interface:
+    ./ebook2audiobook.sh
+        ''',
+        formatter_class=argparse.RawTextHelpFormatter
     )
-
-    # 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
-# Modify the function to handle special cases for Chinese, Italian, and default for others
-def split_long_sentence(sentence, language='en', max_pauses=10):
-    """
-    Splits a sentence into parts based on length or number of pauses without recursion.
-    
-    :param sentence: The sentence to split.
-    :param language: The language of the sentence (default is English).
-    :param max_pauses: Maximum allowed number of pauses in a sentence.
-    :return: A list of sentence parts that meet the criteria.
-    """
-    #Get the Max character length for the selected language -2 : with a default of 248 if no language is found
-    max_length = (char_limits.get(language, 250)-2)
-
-    # Adjust the pause punctuation symbols based on language
-    if language == 'zh-cn':
-        punctuation = ['，', '。', '；', '？', '！']  # Chinese-specific pause punctuation including sentence-ending marks
-    elif language == 'ja':
-        punctuation = ['、', '。', '；', '？', '！']  # Japanese-specific pause punctuation
-    elif language == 'ko':
-        punctuation = ['，', '。', '；', '？', '！']  # Korean-specific pause punctuation
-    elif language == 'ar':
-        punctuation = ['،', '؛', '؟', '!', '·', '؛', '.']  # Arabic-specific punctuation
-    elif language == 'en':
-        punctuation = [',', ';', '.']  # English-specific pause punctuation
-    else:
-        # Default pause punctuation for other languages (es, fr, de, it, pt, pl, cs, ru, nl, tr, hu)
-        punctuation = [',', '.', ';', ':', '?', '!']
-
-
-    
-    parts = []
-    while len(sentence) > max_length or sum(sentence.count(p) for p in punctuation) > max_pauses:
-        possible_splits = [i for i, char in enumerate(sentence) if char in punctuation 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
+    options = [
+        '--script_mode', '--share', '--headless', 
+        '--session', '--ebook', '--ebooks_dir',
+        '--voice', '--language', '--device', '--custom_model',
+        '--temperature', '--length_penalty', '--repetition_penalty', 
+        '--top_k', '--top_p', '--speed',
+        '--enable_text_splitting', '--fine_tuned',
+        '--version', '--help'
+    ]
+    parser.add_argument(options[0], type=str,
+                        help='Force the script to run in NATIVE or DOCKER_UTILS')
+    parser.add_argument(options[1], action='store_true',
+                        help='Enable a public shareable Gradio link. Default to False.')
+    parser.add_argument(options[2], nargs='?', const=True, default=False,
+                        help='Run in headless mode. Default to True if the flag is present without a value, False otherwise.')
+    parser.add_argument(options[3], type=str,
+                        help='Session to reconnect in case of interruption (headless mode only)')
+    parser.add_argument(options[4], type=str,
+                        help='Path to the ebook file for conversion. Required in headless mode.')
+    parser.add_argument(options[5], nargs='?', const='default', type=str,
+                        help=f'Path to the directory containing ebooks for batch conversion. Default to "{os.path.basename(ebooks_dir)}" if "default" is provided.')
+    parser.add_argument(options[6], type=str, default=None,
+                        help='Path to the target voice file for TTS. Optional, must be 24khz for XTTS and 16khz for fairseq models, uses a default voice if not provided.')
+    parser.add_argument(options[7], type=str, default=default_language_code,
+                        help=f'Language for the audiobook conversion. Options: {lang_list_str}. Default to English (eng).')
+    parser.add_argument(options[8], type=str, default='cpu', choices=['cpu', 'gpu'],
+                        help=f'Type of processor unit for the audiobook conversion. If not specified: check first if gpu available, if not cpu is selected.')
+    parser.add_argument(options[9], type=str,
+                        help=f'Path to the custom model (.zip file containing {default_model_files}). Required if using a custom model.')
+    parser.add_argument(options[10], type=float, default=0.65,
+                        help='Temperature for the model. Default to 0.65. Higher temperatures lead to more creative outputs.')
+    parser.add_argument(options[11], type=float, default=1.0,
+                        help='A length penalty applied to the autoregressive decoder. Default to 1.0. Not applied to custom models.')
+    parser.add_argument(options[12], type=float, default=2.5,
+                        help='A penalty that prevents the autoregressive decoder from repeating itself. Default to 2.5')
+    parser.add_argument(options[13], type=int, default=50,
+                        help='Top-k sampling. Lower values mean more likely outputs and increased audio generation speed. Default to 50')
+    parser.add_argument(options[14], type=float, default=0.8,
+                        help='Top-p sampling. Lower values mean more likely outputs and increased audio generation speed. Default to 0.8')
+    parser.add_argument(options[15], type=float, default=1.0,
+                        help='Speed factor for the speech generation. Default to 1.0')
+    parser.add_argument(options[16], action='store_true',
+                        help='Enable splitting text into sentences. Default to False.')                     
+    parser.add_argument(options[17], type=str, default=default_fine_tuned,
+                        help='Name of the fine tuned model. Optional, uses the standard model according to the TTS engine and language.')
+    parser.add_argument(options[18], action='version',version=f'ebook2audiobook version {version}',
+                        help='Show the version of the script and exit')
+
+    for arg in sys.argv:
+        if arg.startswith('--') and arg not in options:
+            print(f'Error: Unrecognized option "{arg}"')
+            sys.exit(1)
+
+    args = vars(parser.parse_args())
+
+    # Check if the port is already in use to prevent multiple launches
+    if not args['headless'] and is_port_in_use(interface_port):
+        print(f'Error: Port {interface_port} is already in use. The web interface may already be running.')
+        sys.exit(1)
+
+    args['script_mode'] = args['script_mode'] if args['script_mode'] else NATIVE
+    args['share'] =  args['share'] if args['share'] else False
+
+    if args['script_mode'] == NATIVE:
+        check_pkg = check_and_install_requirements(requirements_file)
+        if check_pkg:
+            if not check_dictionary():
+                sys.exit(1)
         else:
-            # If no punctuation to split on within max_length, split at max_length
-            split_at = max_length
-        
-        # Split the sentence and add the first part to the list
-        parts.append(sentence[:split_at].strip())
-        sentence = sentence[split_at:].strip()
-    
-    # Add the remaining part of the sentence
-    parts.append(sentence)
-    return parts
-
-"""
-if 'tts' not in locals():
-    tts = TTS(selected_tts_model, progress_bar=True).to(device)
-"""
-from tqdm import tqdm
-
-# Convert chapters to audio using XTTS
-
-def convert_chapters_to_audio_custom_model(chapters_dir, output_audio_dir, temperature, length_penalty, repetition_penalty, top_k, top_p, speed, enable_text_splitting, target_voice_path=None, language=None, custom_model=None):
-
-    if target_voice_path==None:
-        target_voice_path = default_target_voice_path
-
-    if custom_model:
-        print("Loading custom model...")
-        config = XttsConfig()
-        config.load_json(custom_model['config'])
-        model = Xtts.init_from_config(config)
-        model.load_checkpoint(config, checkpoint_path=custom_model['model'], vocab_path=custom_model['vocab'], use_deepspeed=False)
-        model.to(device)
-        print("Computing speaker latents...")
-        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=[target_voice_path])
-    else:
-        selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
-        tts = TTS(selected_tts_model, progress_bar=False).to(device)
-
-    if not os.path.exists(output_audio_dir):
-        os.makedirs(output_audio_dir)
-
-    for chapter_file in sorted(os.listdir(chapters_dir)):
-        if chapter_file.endswith('.txt'):
-            match = re.search(r"chapter_(\d+).txt", chapter_file)
-            if match:
-                chapter_num = int(match.group(1))
+            print('Some packages could not be installed')
+            sys.exit(1)
+    
+    from lib.functions import web_interface, convert_ebook
+
+    # Conditions based on the --headless flag
+    if args['headless']:
+        args['is_gui_process'] = False
+        args['audiobooks_dir'] = audiobooks_cli_dir
+
+        # Condition to stop if both --ebook and --ebooks_dir are provided
+        if args['ebook'] and args['ebooks_dir']:
+            print('Error: You cannot specify both --ebook and --ebooks_dir in headless mode.')
+            sys.exit(1)
+
+        # Condition 1: If --ebooks_dir exists, check value and set 'ebooks_dir'
+        if args['ebooks_dir']:
+            new_ebooks_dir = None
+            if args['ebooks_dir'] == 'default':
+                print(f'Using the default ebooks_dir: {ebooks_dir}')
+                new_ebooks_dir =  os.path.abspath(ebooks_dir)
             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()
-                # Check if the language code is supported
-                nltk_language = language_mapping.get(language)
-                if nltk_language:
-                    # If the language is supported, tokenize using sent_tokenize
-                    sentences = sent_tokenize(chapter_text, language=nltk_language)
+                # Check if the directory exists
+                if os.path.exists(args['ebooks_dir']):
+                    new_ebooks_dir = os.path.abspath(args['ebooks_dir'])
                 else:
-                    # If the language is not supported, handle it (e.g., return the text unchanged)
-                    sentences = [chapter_text]  # No tokenization, just wrap the text in a list
-                #sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
-                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
-                    fragments = split_long_sentence(sentence, language=language)
-                    for fragment in fragments:
-                        if fragment != "":
-                            print(f"Generating fragment: {fragment}...")
-                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
-                            if custom_model:
-                                # length penalty will not apply for custome models, its just too much of a headache perhaps if someone else can do it for me lol, im just one man :(
-                                out = model.inference(fragment, language, gpt_cond_latent, speaker_embedding, temperature=temperature, repetition_penalty=repetition_penalty, top_k=top_k, top_p=top_p, speed=speed, enable_text_splitting=enable_text_splitting)
-                                #out = model.inference(fragment, language, gpt_cond_latent, speaker_embedding, temperature, length_penalty, repetition_penalty, top_k, top_p, speed, enable_text_splitting)
-                                torchaudio.save(fragment_file_path, torch.tensor(out["wav"]).unsqueeze(0), 24000)
-                            else:
-                                speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
-                                language_code = language if language else default_language_code
-                                tts.tts_to_file(text=fragment, file_path=fragment_file_path, speaker_wav=speaker_wav_path, language=language_code, temperature=temperature, length_penalty=length_penalty, repetition_penalty=repetition_penalty, top_k=top_k, top_p=top_p, speed=speed, enable_text_splitting=enable_text_splitting)
-
-                            temp_count += 1
-
-            combine_wav_files(temp_audio_directory, output_audio_dir, output_file_name)
-            wipe_folder(temp_audio_directory)
-            print(f"Converted chapter {chapter_num} to audio.")
-
-
-
-def convert_chapters_to_audio_standard_model(chapters_dir, output_audio_dir, temperature, length_penalty, repetition_penalty, top_k, top_p, speed, enable_text_splitting, target_voice_path=None, language="en"):
-    selected_tts_model = "tts_models/multilingual/multi-dataset/xtts_v2"
-    tts = TTS(selected_tts_model, progress_bar=False).to(device)
-
-    if not os.path.exists(output_audio_dir):
-        os.makedirs(output_audio_dir)
-
-    for chapter_file in sorted(os.listdir(chapters_dir)):
-        if chapter_file.endswith('.txt'):
-            match = re.search(r"chapter_(\d+).txt", chapter_file)
-            if match:
-                chapter_num = int(match.group(1))
+                    print(f'Error: The provided --ebooks_dir "{args["ebooks_dir"]}" does not exist.')
+                    sys.exit(1)
+                    
+            if os.path.exists(new_ebooks_dir):
+                for file in os.listdir(new_ebooks_dir):
+                    # Process files with supported ebook formats
+                    if any(file.endswith(ext) for ext in ebook_formats):
+                        full_path = os.path.join(new_ebooks_dir, file)
+                        print(f'Processing eBook file: {full_path}')
+                        args['ebook'] = full_path
+                        progress_status, audiobook_file = convert_ebook(args)
+                        if audiobook_file is None:
+                            print(f'Conversion failed: {progress_status}')
+                            sys.exit(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()
-                # Check if the language code is supported
-                nltk_language = language_mapping.get(language)
-                if nltk_language:
-                    # If the language is supported, tokenize using sent_tokenize
-                    sentences = sent_tokenize(chapter_text, language=nltk_language)
-                else:
-                    # If the language is not supported, handle it (e.g., return the text unchanged)
-                    sentences = [chapter_text]  # No tokenization, just wrap the text in a list
-                #sentences = sent_tokenize(chapter_text, language='italian' if language == 'it' else 'english')
-                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
-                    fragments = split_long_sentence(sentence, language=language)
-                    for fragment in fragments:
-                        if fragment != "":
-                            print(f"Generating fragment: {fragment}...")
-                            fragment_file_path = os.path.join(temp_audio_directory, f"{temp_count}.wav")
-                            speaker_wav_path = target_voice_path if target_voice_path else default_target_voice_path
-                            tts.tts_to_file(
-                                text=fragment, 
-                                file_path=fragment_file_path, 
-                                speaker_wav=speaker_wav_path, 
-                                language=language, 
-                                temperature=temperature, 
-                                length_penalty=length_penalty, 
-                                repetition_penalty=repetition_penalty, 
-                                top_k=top_k, 
-                                top_p=top_p, 
-                                speed=speed, 
-                                enable_text_splitting=enable_text_splitting
-                            )
-
-                            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.")
-
+                print(f'Error: The directory {new_ebooks_dir} does not exist.')
+                sys.exit(1)
 
+        elif args['ebook']:
+            progress_status, audiobook_file = convert_ebook(args)
+            if audiobook_file is None:
+                print(f'Conversion failed: {progress_status}')
+                sys.exit(1)
 
-# Define the functions to be used in the Gradio interface
-def convert_ebook_to_audio(ebook_file, target_voice_file, language, use_custom_model, custom_model_file, custom_config_file, custom_vocab_file, temperature, length_penalty, repetition_penalty, top_k, top_p, speed, enable_text_splitting, custom_model_url=None, progress=gr.Progress()):
-
-    ebook_file_path = args.ebook if args.ebook else ebook_file.name
-    target_voice = args.voice if args.voice else target_voice_file.name if target_voice_file else None
-    custom_model = None
-
-
-    working_files = os.path.join(".", "Working_files", "temp_ebook")
-    full_folder_working_files = os.path.join(".", "Working_files")
-    chapters_directory = os.path.join(".", "Working_files", "temp_ebook")
-    output_audio_directory = os.path.join(".", 'Chapter_wav_files')
-    remove_folder_with_contents(full_folder_working_files)
-    remove_folder_with_contents(output_audio_directory)
-
-    # If running in headless mode, use the language from args
-    if args.headless and args.language:
-        language = args.language
-    else:
-        language = language  # Gradio dropdown value
-
-    # If headless is used with the custom model arguments
-    if args.use_custom_model and args.custom_model and args.custom_config and args.custom_vocab:
-        custom_model = {
-            'model': args.custom_model,
-            'config': args.custom_config,
-            'vocab': args.custom_vocab
-        }
-
-    elif use_custom_model and custom_model_file and custom_config_file and custom_vocab_file:
-        custom_model = {
-            'model': custom_model_file.name,
-            'config': custom_config_file.name,
-            'vocab': custom_vocab_file.name
-        }
-    if (use_custom_model and custom_model_url) or (args.use_custom_model and custom_model_url):
-        print(f"Received custom model URL: {custom_model_url}")
-        download_dir = os.path.join(".", "Working_files", "custom_model")
-        download_and_extract_zip(custom_model_url, download_dir)
-
-        # Check if vocab.json exists and rename it
-        if rename_vocab_file_if_exists(download_dir):
-            print("vocab.json file was found and renamed.")
-        
-        custom_model = {
-            'model': os.path.join(download_dir, 'model.pth'),
-            'config': os.path.join(download_dir, 'config.json'),
-            'vocab': os.path.join(download_dir, 'vocab.json_')
-        }
-    
-    try:
-        progress(0, desc="Starting conversion")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-    
-    if not calibre_installed():
-        return "Calibre is not installed."
-    
-    
-    try:
-        progress(0.1, desc="Creating chapter-labeled book")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-    
-    create_chapter_labeled_book(ebook_file_path)
-    audiobook_output_path = os.path.join(".", "Audiobooks")
-    
-    try:
-        progress(0.3, desc="Converting chapters to audio")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-    
-    if use_custom_model:
-        convert_chapters_to_audio_custom_model(chapters_directory, output_audio_directory, temperature, length_penalty, repetition_penalty, top_k, top_p, speed, enable_text_splitting, target_voice, language, custom_model)
+        else:
+            print('Error: In headless mode, you must specify either an ebook file using --ebook or an ebook directory using --ebooks_dir.')
+            sys.exit(1)       
     else:
-        convert_chapters_to_audio_standard_model(chapters_directory, output_audio_directory, temperature, length_penalty, repetition_penalty, top_k, top_p, speed, enable_text_splitting, target_voice, language)
-    
-    try:
-        progress(0.9, desc="Creating M4B from chapters")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-    
-    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)
-    
-    # Get the name of the created M4B file
-    m4b_filename = os.path.splitext(os.path.basename(ebook_file_path))[0] + '.m4b'
-    m4b_filepath = os.path.join(audiobook_output_path, m4b_filename)
-
-    try:
-        progress(1.0, desc="Conversion complete")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-    print(f"Audiobook created at {m4b_filepath}")
-    return f"Audiobook created at {m4b_filepath}", m4b_filepath
-
-
-def list_audiobook_files(audiobook_folder):
-    # List all files in the audiobook folder
-    files = []
-    for filename in os.listdir(audiobook_folder):
-        if filename.endswith('.m4b'):  # Adjust the file extension as needed
-            files.append(os.path.join(audiobook_folder, filename))
-    return files
-
-def download_audiobooks():
-    audiobook_output_path = os.path.join(".", "Audiobooks")
-    return list_audiobook_files(audiobook_output_path)
-
-
-# Gradio UI setup
-def run_gradio_interface():
-    language_options = [
-        "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"
-    ]
-
-    theme = gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="blue",
-        neutral_hue="blue",
-        text_size=gr.themes.sizes.text_md,
-    )
-
-# Gradio UI setup
-def run_gradio_interface():
-    language_options = [
-        "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"
-    ]
-
-    theme = gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="blue",
-        neutral_hue="blue",
-        text_size=gr.themes.sizes.text_md,
-    )
-
-    with gr.Blocks(theme=theme) as demo:
-        gr.Markdown(
-        """
-        # eBook to Audiobook Converter
-
-        Transform your eBooks into immersive audiobooks with optional custom TTS models.
-
-        This interface is based on [Ebook2AudioBookXTTS](https://github.com/DrewThomasson/ebook2audiobookXTTS).
-
-        Xtts is very slow, you should just run it locally with docker, info in ebook2audiobookxtts github
-
-        Run it Locally for Free! 
-        [![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/DrewThomasson/ebook2audiobookXTTS)
-
-        Or on Free Google Colab [![Free Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DrewThomasson/ebook2audiobookXTTS/blob/main/Notebooks/colab_ebook2audiobookxtts.ipynb)
-
-        """
-        )
-
-        with gr.Tabs():  # Create tabs for better UI organization
-            with gr.TabItem("Input Options"):
-                with gr.Row():
-                    with gr.Column(scale=3):
-                        ebook_file = gr.File(label="eBook File")
-                        target_voice_file = gr.File(label="Target Voice File (Optional)")
-                        language = gr.Dropdown(label="Language", choices=language_options, value="en")
-
-                    with gr.Column(scale=3):
-                        use_custom_model = gr.Checkbox(label="Use Custom Model")
-                        custom_model_file = gr.File(label="Custom Model File (Optional)", visible=False)
-                        custom_config_file = gr.File(label="Custom Config File (Optional)", visible=False)
-                        custom_vocab_file = gr.File(label="Custom Vocab File (Optional)", visible=False)
-                        custom_model_url = gr.Textbox(label="Custom Model Zip URL (Optional)", visible=False)
-
-            with gr.TabItem("Audio Generation Preferences"):  # New tab for 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.
-                """
-                )
-                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."
-                )
-                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."
-                )
-                repetition_penalty = gr.Slider(
-                    label="Repetition Penalty", 
-                    minimum=1.0, 
-                    maximum=10.0, 
-                    step=0.1, 
-                    value=2.0, 
-                    info="Penalizes repeated phrases. Higher values reduce repetition."
-                )
-                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. "
-                )
-                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."
-                )
-                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."
-                )
-                enable_text_splitting = gr.Checkbox(
-                    label="Enable Text Splitting", 
-                    value=False,
-                    info="Splits long texts into sentences to generate audio in chunks. Useful for very long inputs."
-                )
-
-        convert_btn = gr.Button("Convert to Audiobook", variant="primary")
-        output = gr.Textbox(label="Conversion Status")
-        audio_player = gr.Audio(label="Audiobook Player", type="filepath")
-        download_btn = gr.Button("Download Audiobook Files")
-        download_files = gr.File(label="Download Files", interactive=False)
-
-        convert_btn.click(
-            lambda *args: convert_ebook_to_audio(
-                *args[:7], 
-                float(args[7]),  # Ensure temperature is float
-                float(args[8]),  # Ensure length_penalty is float
-                float(args[9]),  # Ensure repetition_penalty is float
-                int(args[10]),   # Ensure top_k is int
-                float(args[11]), # Ensure top_p is float
-                float(args[12]), # Ensure speed is float
-                *args[13:]
-            ),
-            inputs=[
-                ebook_file, target_voice_file, language, use_custom_model, custom_model_file, custom_config_file, 
-                custom_vocab_file, temperature, length_penalty, repetition_penalty, 
-                top_k, top_p, speed, enable_text_splitting, custom_model_url
-            ],
-            outputs=[output, audio_player]
-        )
-
-
-        use_custom_model.change(
-            lambda x: [gr.update(visible=x)] * 4,
-            inputs=[use_custom_model],
-            outputs=[custom_model_file, custom_config_file, custom_vocab_file, custom_model_url]
-        )
-
-        download_btn.click(
-            download_audiobooks,
-            outputs=[download_files]
-        )
-
-    # Get the correct local IP or localhost
-    hostname = socket.gethostname()
-    local_ip = socket.gethostbyname(hostname)
-
-    # Ensure Gradio runs and prints the correct local IP
-    print(f"Running on local URL: http://{local_ip}:7860")
-    print(f"Running on local URL: http://localhost:7860")
-
-    # Launch Gradio app
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=args.share)
-
-
-
-
-
-# Check if running in headless mode
-if args.headless:
-    # If the arg.custom_model_url exists then use it as the custom_model_url lol
-    custom_model_url = args.custom_model_url if args.custom_model_url else None
-    
-    if not args.ebook:
-        print("Error: In headless mode, you must specify an ebook file using --ebook.")
-        exit(1)
-
-    ebook_file_path = args.ebook
-    target_voice = args.voice if args.voice else None
-    custom_model = None
-
-    if args.use_custom_model:
-        # Check if custom_model_url is provided
-        if args.custom_model_url:
-            # Download the custom model from the provided URL
-            custom_model_url = args.custom_model_url
+        args['is_gui_process'] = True
+        passed_arguments = sys.argv[1:]
+        allowed_arguments = {'--share', '--script_mode'}
+        passed_args_set = {arg for arg in passed_arguments if arg.startswith('--')}
+        if passed_args_set.issubset(allowed_arguments):
+             web_interface(args)
         else:
-            # If no URL is provided, ensure all custom model files are provided
-            if not args.custom_model or not args.custom_config or not args.custom_vocab:
-                print("Error: You must provide either a --custom_model_url or all of the following arguments:")
-                print("--custom_model, --custom_config, and --custom_vocab")
-                exit(1)
-            else:
-                # Assign the custom model files
-                custom_model = {
-                    'model': args.custom_model,
-                    'config': args.custom_config,
-                    'vocab': args.custom_vocab
-                }
-
-
+            print('Error: In non-headless mode, no option or only --share can be passed')
+            sys.exit(1)
 
-    # Example headless execution
-    convert_ebook_to_audio(ebook_file_path, target_voice, args.language, args.use_custom_model, args.custom_model, args.custom_config, args.custom_vocab, args.temperature, args.length_penalty, args.repetition_penalty, args.top_k, args.top_p, args.speed, args.enable_text_splitting, custom_model_url)
-
-
-else:
-    # Launch Gradio UI
-    run_gradio_interface()
+if __name__ == '__main__':
+    if not check_python_version():
+        sys.exit(1)
+    else:
+        main()

download_tos_agreed_file.py

@@ -1,23 +0,0 @@
-import os
-import urllib.request
-
-def download_tos_agreed():
-    # Get the current user's home directory
-    user_home = os.path.expanduser('~')
-    
-    # Set the destination directory and file URL
-    dest_dir = os.path.join(user_home, '.local', 'share', 'tts', 'tts_models--multilingual--multi-dataset--xtts_v2')
-    file_url = "https://github.com/DrewThomasson/VoxNovel/raw/main/readme_files/tos_agreed.txt"
-    
-    # Create the destination directory if it doesn't exist
-    os.makedirs(dest_dir, exist_ok=True)
-    
-    # Download the file to the destination directory
-    file_path = os.path.join(dest_dir, 'tos_agreed.txt')
-    urllib.request.urlretrieve(file_url, file_path)
-    
-    print(f"File has been saved to {file_path}")
-    print("The tos_agreed.txt file is so that you don't have to tell coqio TTS yes when downloading the xtts_v2 model.")
-
-# Run the download function
-download_tos_agreed()

ebook2audiobook.sh

@@ -0,0 +1,300 @@
+#!/usr/bin/env bash
+
+PYTHON_VERSION="3.12"
+export TTS_CACHE="./models"
+
+ARGS="$@"
+
+# Declare an associative array
+declare -A arguments
+
+# Parse arguments
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+        --*)
+            key="${1/--/}" # Remove leading '--'
+            if [[ -n "$2" && ! "$2" =~ ^-- ]]; then
+                # If the next argument is a value (not another option)
+                arguments[$key]="$2"
+                shift # Move past the value
+            else
+                # Set to true for flags without values
+                arguments[$key]=true
+            fi
+            ;;
+        *)
+            echo "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+    shift # Move to the next argument
+done
+
+NATIVE="native"
+DOCKER_UTILS="docker_utils"
+FULL_DOCKER="full_docker"
+
+SCRIPT_MODE="$NATIVE"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+WGET=$(which wget 2>/dev/null)
+REQUIRED_PROGRAMS=("calibre" "ffmpeg")
+DOCKER_UTILS_IMG="utils"
+PYTHON_ENV="python_env"
+CURRENT_ENV=""
+
+if [[ "$OSTYPE" = "darwin"* ]]; then
+    CONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh"
+else
+	CONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh"
+fi
+CONDA_INSTALLER=/tmp/Miniconda3-latest.sh
+CONDA_INSTALL_DIR=$HOME/miniconda3
+CONDA_PATH=$HOME/miniconda3/bin
+CONDA_ENV=~/miniconda3/etc/profile.d/conda.sh
+CONFIG_FILE="$HOME/.bashrc"
+PATH="$CONDA_PATH:$PATH"
+
+declare -a programs_missing
+
+# Check if the current script is run inside a docker container
+if [[ -n "$container" || -f /.dockerenv ]]; then
+	SCRIPT_MODE="$FULL_DOCKER"
+else
+	if [[ -n "${arguments['script_mode']+exists}" ]]; then
+		if [ "${arguments['script_mode']}" = "$NATIVE" ] || [ "${arguments['script_mode']}" = "$DOCKER_UTILS" ]; then
+			SCRIPT_MODE="${arguments['script_mode']}"
+		fi
+	fi
+fi
+
+# Check if running in a Conda or Python virtual environment
+if [[ -n "$CONDA_DEFAULT_ENV" ]]; then
+    CURRENT_ENV="$CONDA_PREFIX"
+elif [[ -n "$VIRTUAL_ENV" ]]; then
+    CURRENT_ENV="$VIRTUAL_ENV"
+fi
+
+# If neither environment variable is set, check Python path
+if [[ -z "$CURRENT_ENV" ]]; then
+    PYTHON_PATH=$(which python 2>/dev/null)
+    if [[ ( -n "$CONDA_PREFIX" && "$PYTHON_PATH" == "$CONDA_PREFIX/bin/python" ) || ( -n "$VIRTUAL_ENV" && "$PYTHON_PATH" == "$VIRTUAL_ENV/bin/python" ) ]]; then
+        CURRENT_ENV="${CONDA_PREFIX:-$VIRTUAL_ENV}"
+    fi
+fi
+
+# Output result if a virtual environment is detected
+if [[ -n "$CURRENT_ENV" ]]; then
+    echo -e "Current python virtual environment detected: $CURRENT_ENV."
+    echo -e "This script runs with its own virtual env and must be out of any other virtual environment when it's launched."
+    echo -e "If you are using miniconda then you would type in:"
+    echo -e "conda deactivate"
+    exit 1
+fi
+
+function required_programs_check {
+	local programs=("$@")
+	for program in "${programs[@]}"; do
+		if ! command -v "$program" >/dev/null 2>&1; then
+			echo -e "\e[33m$program is not installed.\e[0m"
+			programs_missing+=($program)
+		fi
+	done
+	local count=${#programs_missing[@]}
+	if [[ $count -eq 0 ]]; then
+		return 0
+	else
+		return 1
+	fi
+}
+
+function install_programs {
+	echo -e "\e[33mInstalling required programs. NOTE: you must have 'sudo' priviliges or it will fail.\e[0m"
+	if [[ "$OSTYPE" = "darwin"* ]]; then
+		PACK_MGR="brew install"
+			if ! command -v brew &> /dev/null; then
+				echo -e "\e[33mHomebrew is not installed. Installing Homebrew...\e[0m"
+				/usr/bin/env bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+				echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
+				eval "$(/opt/homebrew/bin/brew shellenv)"
+			fi
+	else
+		if command -v emerge &> /dev/null; then
+			PACK_MGR="sudo emerge"
+		elif command -v dnf &> /dev/null; then
+			PACK_MGR="sudo dnf install"
+			PACK_MGR_OPTIONS="-y"
+		elif command -v yum &> /dev/null; then
+			PACK_MGR="sudo yum install"
+			PACK_MGR_OPTIONS="-y"
+		elif command -v zypper &> /dev/null; then
+			PACK_MGR="sudo zypper install"
+			PACK_MGR_OPTIONS="-y"
+		elif command -v pacman &> /dev/null; then
+			PACK_MGR="sudo pacman -Sy"
+		elif command -v apt-get &> /dev/null; then
+			sudo apt-get update
+			PACK_MGR="sudo apt-get install"
+			PACK_MGR_OPTIONS="-y"
+		elif command -v apk &> /dev/null; then
+			PACK_MGR="sudo apk add"
+		else
+			echo "Cannot recognize your applications package manager. Please install the required applications manually."
+			return 1
+		fi
+		
+	fi
+	if [ -z "$WGET" ]; then
+		echo -e "\e[33m wget is missing! trying to install it... \e[0m"
+		result=$(eval "$PACK_MGR wget $PACK_MGR_OPTIONS" 2>&1)
+		result_code=$?
+		if [ $result_code -eq 0 ]; then
+			WGET=$(which wget 2>/dev/null)
+		else
+			echo "Cannot 'wget'. Please install 'wget'  manually."
+			return 1
+		fi
+	fi
+	for program in "${programs_missing[@]}"; do
+		if [ "$program" = "calibre" ];then				
+			# avoid conflict with calibre builtin lxml
+			pip uninstall lxml -y 2>/dev/null
+			echo -e "\e[33mInstalling Calibre...\e[0m"
+			if [[ "$OSTYPE" = "darwin"* ]]; then
+				eval "$PACK_MGR --cask calibre"
+			else
+				$WGET -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sh /dev/stdin
+			fi
+			if command -v calibre >/dev/null 2>&1; then
+				echo -e "\e[32m===============>>> Calibre is installed! <<===============\e[0m"
+			else
+				echo "Calibre installation failed."
+			fi
+		else
+			eval "$PACK_MGR $program $PKG_MGR_OPTIONS"				
+			if command -v $program >/dev/null 2>&1; then
+				echo -e "\e[32m===============>>> $program is installed! <<===============\e[0m"
+			else
+				echo "$program installation failed."
+			fi
+		fi
+	done
+	if required_programs_check "${REQUIRED_PROGRAMS[@]}"; then
+		return 0
+	else
+		echo -e "\e[33mYou can run 'ebook2audiobook.sh --script_mode docker_utils' to avoid to install $REQUIRED_PROGRAMS natively.\e[0m"
+		return 1
+	fi
+}
+
+function conda_check {
+	if ! command -v conda &> /dev/null; then
+		echo -e "\e[33mconda is not installed!\e[0m"
+		echo -e "\e[33mDownloading conda installer...\e[0m"
+		wget -O "$CONDA_INSTALLER" "$CONDA_URL"
+		if [[ -f "$CONDA_INSTALLER" ]]; then
+			echo -e "\e[33mInstalling Miniconda...\e[0m"
+			bash "$CONDA_INSTALLER" -u -b -p "$CONDA_INSTALL_DIR"
+			rm -f "$CONDA_INSTALLER"
+			if [[ -f "$CONDA_INSTALL_DIR/bin/conda" ]]; then
+				conda init
+				echo -e "\e[32m===============>>> conda is installed! <<===============\e[0m"
+			else
+				echo -e "\e[31mconda installation failed.\e[0m"		
+				return 1
+			fi
+		else
+			echo -e "\e[31mFailed to download Miniconda installer.\e[0m"
+			echo -e "\e[33mI'ts better to use the install.sh to install everything needed.\e[0m"
+			return 1
+		fi
+	fi
+	if [[ ! -d $SCRIPT_DIR/$PYTHON_ENV ]]; then
+		# Use this condition to chmod writable folders once
+		chmod -R 777 ./audiobooks ./tmp ./models
+		conda create --prefix $SCRIPT_DIR/$PYTHON_ENV python=$PYTHON_VERSION -y
+		source $CONDA_ENV
+		conda activate $SCRIPT_DIR/$PYTHON_ENV
+		python -m pip install --upgrade pip
+		python -m pip install --upgrade -r requirements.txt --progress-bar=on
+		conda deactivate
+	fi
+	return 0
+}
+
+function docker_check {
+	if ! command -v docker &> /dev/null; then
+		echo -e "\e[33m docker is missing! trying to install it... \e[0m"
+		if [[ "$OSTYPE" == "darwin"* ]]; then
+			echo "Installing Docker using Homebrew..."
+			$PACK_MGR --cask docker $PACK_MGR_OPTIONS
+		else
+			$WGET -qO get-docker.sh https://get.docker.com && \
+			sudo sh get-docker.sh
+			sudo systemctl start docker
+			sudo systemctl enable docker
+			docker run hello-world
+			rm -f get-docker.sh
+		fi
+		echo -e "\e[32m===============>>> docker is installed! <<===============\e[0m"
+		docker_build
+	else
+		# Check if Docker service is running
+		if docker info >/dev/null 2>&1; then
+			if [[ "$(docker images -q $DOCKER_UTILS_IMG 2> /dev/null)" = "" ]]; then
+				docker_build
+			fi
+		else
+			echo -e "\e[33mDocker is not running\e[0m"
+			return 1
+		fi
+	fi
+	return 0
+}
+
+function docker_build {
+# Check if the Docker socket is accessible
+	if [[ -e /var/run/docker.sock || -e /run/docker.sock ]]; then
+		echo -e "\e[33mDocker image '$DOCKER_UTILS_IMG' not found. Trying to build it...\e[0m"
+		docker build -f DockerfileUtils -t utils .
+	else
+		echo -e "\e[33mcannot connect to docker socket. Check if the docker socket is running.\e[0m"
+	fi
+}
+
+if [ "$SCRIPT_MODE" = "$FULL_DOCKER" ]; then
+	echo -e "\e[33mRunning in $FULL_DOCKER mode\e[0m"
+	python app.py --script_mode $SCRIPT_MODE $ARGS
+elif [[ "$SCRIPT_MODE" == "$NATIVE" || "$SCRIPT_MODE" = "$DOCKER_UTILS" ]]; then
+	pass=true
+	if [ "$SCRIPT_MODE" == "$NATIVE" ]; then
+		echo -e "\e[33mRunning in $NATIVE mode\e[0m"
+		if ! required_programs_check "${REQUIRED_PROGRAMS[@]}"; then
+			if ! install_programs; then
+				pass=false
+			fi
+		fi
+	else
+		echo -e "\e[33mRunning in $DOCKER_UTILS mode\e[0m"
+		if conda_check; then
+			if docker_check; then
+				source $CONDA_ENV
+				conda activate $SCRIPT_DIR/$PYTHON_ENV
+				python app.py --script_mode $DOCKER_UTILS $ARGS
+				conda deactivate
+			fi
+		fi
+	fi
+	if [ $pass = true ]; then
+		if conda_check; then
+			source $CONDA_ENV
+			conda activate $SCRIPT_DIR/$PYTHON_ENV
+			python app.py --script_mode $SCRIPT_MODE $ARGS
+			conda deactivate
+		fi
+	fi
+else
+	echo -e "\e[33mebook2audiobook is not correctly installed or run.\e[0m"
+fi
+
+exit 0

ebook2audiobookXTTS/Dockerfile

@@ -1,93 +0,0 @@
-# Use an official NVIDIA CUDA image with cudnn8 and Ubuntu 20.04 as the base
-FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu20.04
-
-# Set non-interactive installation to avoid timezone and other prompts
-ENV DEBIAN_FRONTEND=noninteractive
-
-# Install necessary packages including Miniconda
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    wget \
-    git \
-    espeak \
-    espeak-ng \
-    ffmpeg \
-    tk \
-    mecab \
-    libmecab-dev \
-    mecab-ipadic-utf8 \
-    build-essential \
-    calibre \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN ebook-convert --version
-
-# Install Miniconda
-RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda.sh && \
-    bash ~/miniconda.sh -b -p /opt/conda && \
-    rm ~/miniconda.sh
-
-
-
-# Set PATH to include conda
-ENV PATH=/opt/conda/bin:$PATH
-
-# Create a conda environment with Python 3.10
-RUN conda create -n ebookenv python=3.10 -y
-
-# Activate the conda environment
-SHELL ["conda", "run", "-n", "ebookenv", "/bin/bash", "-c"]
-
-# Install Python dependencies using conda and pip
-RUN conda install -n ebookenv -c conda-forge \
-    pydub \
-    nltk \
-    mecab-python3 \
-    && pip install --no-cache-dir \
-    bs4 \
-    beautifulsoup4 \
-    ebooklib \
-    tqdm \
-    tts==0.21.3 \
-    unidic \
-    gradio
-
-# Download unidic
-RUN python -m unidic download
-
-# Set the working directory in the container
-WORKDIR /ebook2audiobookXTTS
-
-# Clone the ebook2audiobookXTTS repository
-RUN git clone https://github.com/DrewThomasson/ebook2audiobookXTTS.git .
-
-# Copy test audio file
-COPY default_voice.wav /ebook2audiobookXTTS/
-
-# Run a test to set up XTTS
-RUN echo "import torch" > /tmp/script1.py && \
-    echo "from TTS.api import TTS" >> /tmp/script1.py && \
-    echo "device = 'cuda' if torch.cuda.is_available() else 'cpu'" >> /tmp/script1.py && \
-    echo "print(TTS().list_models())" >> /tmp/script1.py && \
-    echo "tts = TTS('tts_models/multilingual/multi-dataset/xtts_v2').to(device)" >> /tmp/script1.py && \
-    echo "wav = tts.tts(text='Hello world!', speaker_wav='default_voice.wav', language='en')" >> /tmp/script1.py && \
-    echo "tts.tts_to_file(text='Hello world!', speaker_wav='default_voice.wav', language='en', file_path='output.wav')" >> /tmp/script1.py && \
-    yes | python /tmp/script1.py
-
-# Remove the test audio file
-RUN rm -f /ebook2audiobookXTTS/output.wav
-
-# Verify that the script exists and has the correct permissions
-RUN ls -la /ebook2audiobookXTTS/
-
-# Check if the script exists and log its presence
-RUN if [ -f /ebook2audiobookXTTS/custom_model_ebook2audiobookXTTS_with_link_gradio.py ]; then echo "Script found."; else echo "Script not found."; exit 1; fi
-
-# Modify the Python script to set share=True
-RUN sed -i 's/demo.launch(share=False)/demo.launch(share=True)/' /ebook2audiobookXTTS/custom_model_ebook2audiobookXTTS_with_link_gradio.py
-
-# Download the punkt package for nltk
-RUN python -m nltk.downloader punkt
-
-# Set the command to run your GUI application using the conda environment
-CMD ["conda", "run", "--no-capture-output", "-n", "ebookenv", "python", "/ebook2audiobookXTTS/custom_model_ebook2audiobookXTTS_with_link_gradio.py"]
-

ebook2audiobookXTTS/LICENSE

@@ -1,21 +0,0 @@
-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.

ebook2audiobookXTTS/README.md

@@ -1,171 +0,0 @@
-# 📚 ebook2audiobook
-
-Convert eBooks to audiobooks with chapters and metadata using Calibre and Coqui XTTS. Supports optional voice cloning and multiple languages!
-
-## 🌟 Features
-
-- 📖 Converts eBooks to text format with Calibre.
-- 📚 Splits eBook into chapters for organized audio.
-- 🎙️ High-quality text-to-speech with Coqui XTTS.
-- 🗣️ Optional voice cloning with your own voice file.
-- 🌍 Supports multiple languages (English by default).
-- 🖥️ Designed to run on 4GB RAM.
-
-## 🛠️ Requirements
-
-- Python 3.x
-- `coqui-tts` Python package
-- Calibre (for eBook conversion)
-- FFmpeg (for audiobook creation)
-- Optional: Custom voice file for voice cloning
-
-### 🔧 Installation Instructions
-
-1. **Install Python 3.x** from [Python.org](https://www.python.org/downloads/).
-
-2. **Install Calibre**:
-   - **Ubuntu**: `sudo apt-get install -y calibre`
-   - **macOS**: `brew install calibre`
-   - **Windows** (Admin Powershell): `choco install calibre`
-
-3. **Install FFmpeg**:
-   - **Ubuntu**: `sudo apt-get install -y ffmpeg`
-   - **macOS**: `brew install ffmpeg`
-   - **Windows** (Admin Powershell): `choco install ffmpeg`
-
-4. **Optional: Install Mecab** (for non-Latin languages):
-   - **Ubuntu**: `sudo apt-get install -y mecab libmecab-dev mecab-ipadic-utf8`
-   - **macOS**: `brew install mecab`, `brew install mecab-ipadic`
-   - **Windows**: [mecab-website-to-install-manually](https://taku910.github.io/mecab/#download) (Note: Japanese support is limited)
-
-5. **Install Python packages**:
-   ```bash
-   pip install tts==0.21.3 pydub nltk beautifulsoup4 ebooklib tqdm
-   
-   python -m nltk.downloader punkt
-   ```
-
-   **For non-Latin languages**:
-   ```bash
-   pip install mecab mecab-python3 unidic
-   
-   python -m unidic download
-   ```
-
-## 🌐 Supported 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)**
-
-Specify the language code when running the script.
-
-## 🚀 Usage
-
-### 🖥️ Gradio Web Interface
-
-1. **Run the Script**:
-   ```bash
-   python custom_model_ebook2audiobookXTTS_gradio.py
-   ```
-
-2. **Open the Web App**: Click the URL provided in the terminal to access the web app and convert eBooks.
-
-### 📝 Basic Usage
-
-```bash
-python ebook2audiobook.py <path_to_ebook_file> [path_to_voice_file] [language_code]
-```
-
-- **<path_to_ebook_file>**: Path to your eBook file.
-- **[path_to_voice_file]**: Optional for voice cloning.
-- **[language_code]**: Optional to specify language.
-
-### 🧩 Custom XTTS Model
-
-```bash
-python custom_model_ebook2audiobookXTTS.py <ebook_file_path> <target_voice_file_path> <language> <custom_model_path> <custom_config_path> <custom_vocab_path>
-```
-
-- **<ebook_file_path>**: Path to your eBook file.
-- **<target_voice_file_path>**: Optional for voice cloning.
-- **<language>**: Optional to specify language.
-- **<custom_model_path>**: Path to `model.pth`.
-- **<custom_config_path>**: Path to `config.json`.
-- **<custom_vocab_path>**: Path to `vocab.json`.
-
-### 🐳 Using Docker
-
-You can also use Docker to run the eBook to Audiobook converter. This method ensures consistency across different environments and simplifies setup.
-
-#### 🚀 Running the Docker Container
-
-To run the Docker container and start the Gradio interface, use the following command:
-
- -Run with CPU only
-```powershell
-docker run -it --rm -p 7860:7860 --platform=linux/amd64 athomasson2/ebook2audiobookxtts:huggingface python app.py
-```
- -Run with GPU Speedup (Nvida graphics cards only)
-```powershell
-docker run -it --rm --gpus all -p 7860:7860 --platform=linux/amd64 athomasson2/ebook2audiobookxtts:huggingface python app.py
-```
-
-This command will start the Gradio interface on port 7860.(localhost:7860)
-
-#### 🖥️ Docker GUI 
-
-<img width="1401" alt="Screenshot 2024-08-25 at 10 08 40 AM" src="https://github.com/user-attachments/assets/78cfd33e-cd46-41cc-8128-3820160a5e40">
-<img width="1406" alt="Screenshot 2024-08-25 at 10 08 51 AM" src="https://github.com/user-attachments/assets/dbfad9f6-e6e5-4cad-b248-adb76c5434f3">
-
-### 🛠️ For Custom Xtts Models
-
-Models built to be better at a specific voice. Check out my Hugging Face page [here](https://huggingface.co/drewThomasson).
-
-To use a custom model, paste the link of the `Finished_model_files.zip` file like this:
-
-[David Attenborough fine tuned Finished_model_files.zip](https://huggingface.co/drewThomasson/xtts_David_Attenborough_fine_tune/resolve/main/Finished_model_files.zip?download=true)
-
-
-
-
-More details can be found at the [Dockerfile Hub Page]([https://github.com/DrewThomasson/ebook2audiobookXTTS](https://hub.docker.com/repository/docker/athomasson2/ebook2audiobookxtts/general)).
-
-## 🌐 Fine Tuned Xtts models
-
-To find already fine-tuned XTTS models, visit [this Hugging Face link](https://huggingface.co/drewThomasson) 🌐. Search for models that include "xtts fine tune" in their names.
-
-## 🎥 Demos
-
-https://github.com/user-attachments/assets/8486603c-38b1-43ce-9639-73757dfb1031
-
-## 🤗 [Huggingface space demo](https://huggingface.co/spaces/drewThomasson/ebook2audiobookXTTS)
-- Huggingface space is running on free cpu tier so expect very slow or timeout lol, just don't give it giant files is all
-- Best to duplicate space or run locally.
-## 📚 Supported eBook Formats
-
-- `.epub`, `.pdf`, `.mobi`, `.txt`, `.html`, `.rtf`, `.chm`, `.lit`, `.pdb`, `.fb2`, `.odt`, `.cbr`, `.cbz`, `.prc`, `.lrf`, `.pml`, `.snb`, `.cbc`, `.rb`, `.tcr`
-- **Best results**: `.epub` or `.mobi` for automatic chapter detection
-
-## 📂 Output
-
-- Creates an `.m4b` file with metadata and chapters.
-- **Example Output**: ![Example](https://github.com/DrewThomasson/VoxNovel/blob/dc5197dff97252fa44c391dc0596902d71278a88/readme_files/example_in_app.jpeg)
-
-## 🙏 Special Thanks
-
-- **Coqui TTS**: [Coqui TTS GitHub](https://github.com/coqui-ai/TTS)
-- **Calibre**: [Calibre Website](https://calibre-ebook.com)

ebook2audiobookXTTS/custom_model_ebook2audiobookXTTS.py

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

ebook2audiobookXTTS/custom_model_ebook2audiobookXTTS_gradio.py

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

ebook2audiobookXTTS/custom_model_ebook2audiobookXTTS_with_link_gradio.py

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

ebook2audiobookXTTS/ebook2audiobook.py

@@ -1,466 +0,0 @@
-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
-
-#make the nltk folder point to the nltk folder in the app dir
-nltk.data.path.append('/home/user/app/nltk_data')
-
-#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)

ebook2audiobookXTTS/gradio_gui_with_email_and_que.py

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

ebook2audiobookXTTS/import_all_files.py

@@ -1,5 +0,0 @@
-import import_nltk_files
-
-import import_locally_stored_tts_model_files
-
-#import download_tos_agreed_file

ebook2audiobookXTTS/import_locally_stored_tts_model_files.py

@@ -1,23 +0,0 @@
-import os
-import shutil
-
-print("Importing locally stored coqui tts models...")
-
-# Define the source directory and the destination base path
-tts_folder = "/home/user/app/Base_XTTS_Model"
-destination_base = '/home/user/.local/share/'
-
-# Define the destination path for the tts folder
-destination_path = os.path.join(destination_base, 'tts')
-
-# Move the entire tts folder
-if os.path.exists(tts_folder):
-    # Remove the destination folder if it exists
-    if os.path.exists(destination_path):
-        shutil.rmtree(destination_path)  # Remove the existing folder
-    shutil.move(tts_folder, destination_path)
-    print(f'Moved: {tts_folder} to {destination_path}')
-    print("Locally stored base coqui XTTS tts model imported!")
-    print(os.listdir('/home/user/.local/share/tts'))
-else:
-    print(f'Source path does not exist: {tts_folder}')

ebook2audiobookXTTS/import_nltk_files.py

@@ -1,24 +0,0 @@
-import shutil
-import os
-
-try:
-    print("Importing nltk files...")
-
-    # Define source and destination paths
-    source_folder = '/home/user/app/nltk_data'
-    destination_folder = '/home/user/nltk_data'
-
-    # Ensure the destination folder exists, create if it doesn't
-    os.makedirs(destination_folder, exist_ok=True)
-
-    # Move the source folder to the destination
-    shutil.move(source_folder, destination_folder)
-
-    print(f"NLTK folder moved to {destination_folder}")
-
-except FileNotFoundError as fnf_error:
-    print(f"Error: Source folder not found. {fnf_error}")
-except PermissionError as perm_error:
-    print(f"Error: Permission denied. {perm_error}")
-except Exception as e:
-    print(f"An unexpected error occurred: {e}")

ebook2audiobookXTTS/trash.py

@@ -1,366 +0,0 @@
-print("starting...")
-
-import os
-import shutil
-import subprocess
-import re
-from pydub import AudioSegment
-import tempfile
-from tqdm import tqdm
-import gradio as gr
-import nltk
-import ebooklib
-import bs4
-from ebooklib import epub
-from bs4 import BeautifulSoup
-from gradio import Progress
-import sys
-from nltk.tokenize import sent_tokenize
-import csv
-
-
-# Ensure necessary models are downloaded
-# nltk.download('punkt')
-
-def is_folder_empty(folder_path):
-    if os.path.exists(folder_path) and os.path.isdir(folder_path):
-        return not os.listdir(folder_path)
-    else:
-        print(f"The path {folder_path} is not a valid folder.")
-        return None
-
-def remove_folder_with_contents(folder_path):
-    try:
-        shutil.rmtree(folder_path)
-        print(f"Successfully removed {folder_path} and all of its contents.")
-    except Exception as e:
-        print(f"Error removing {folder_path}: {e}")
-
-def wipe_folder(folder_path):
-    if not os.path.exists(folder_path):
-        print(f"The folder {folder_path} does not exist.")
-        return
-    for item in os.listdir(folder_path):
-        item_path = os.path.join(folder_path, item)
-        if os.path.isfile(item_path):
-            os.remove(item_path)
-        elif os.path.isdir(item_path):
-            shutil.rmtree(item_path)
-    
-    print(f"All contents wiped from {folder_path}.")
-
-def create_m4b_from_chapters(input_dir, ebook_file, output_dir):
-    def sort_key(chapter_file):
-        numbers = re.findall(r'\d+', chapter_file)
-        return int(numbers[0]) if numbers else 0
-
-    def extract_metadata_and_cover(ebook_path):
-        try:
-            cover_path = ebook_path.rsplit('.', 1)[0] + '.jpg'
-            subprocess.run(['ebook-meta', ebook_path, '--get-cover', cover_path], check=True)
-            if (os.path.exists(cover_path)):
-                return cover_path
-        except Exception as e:
-            print(f"Error extracting eBook metadata or cover: {e}")
-        return None
-
-    def combine_wav_files(chapter_files, output_path):
-        combined_audio = AudioSegment.empty()
-
-        for chapter_file in chapter_files:
-            audio_segment = AudioSegment.from_wav(chapter_file)
-            combined_audio += audio_segment
-        combined_audio.export(output_path, format='wav')
-        print(f"Combined audio saved to {output_path}")
-
-    def generate_ffmpeg_metadata(chapter_files, metadata_file):
-        with open(metadata_file, 'w') as file:
-            file.write(';FFMETADATA1\n')
-            start_time = 0
-            for index, chapter_file in enumerate(chapter_files):
-                duration_ms = len(AudioSegment.from_wav(chapter_file))
-                file.write(f'[CHAPTER]\nTIMEBASE=1/1000\nSTART={start_time}\n')
-                file.write(f'END={start_time + duration_ms}\ntitle=Chapter {index + 1}\n')
-                start_time += duration_ms
-
-    def create_m4b(combined_wav, metadata_file, cover_image, output_m4b):
-        os.makedirs(os.path.dirname(output_m4b), exist_ok=True)
-        
-        ffmpeg_cmd = ['ffmpeg', '-i', combined_wav, '-i', metadata_file]
-        if cover_image:
-            ffmpeg_cmd += ['-i', cover_image, '-map', '0:a', '-map', '2:v']
-        else:
-            ffmpeg_cmd += ['-map', '0:a']
-        
-        ffmpeg_cmd += ['-map_metadata', '1', '-c:a', 'aac', '-b:a', '192k']
-        if cover_image:
-            ffmpeg_cmd += ['-c:v', 'png', '-disposition:v', 'attached_pic']
-        ffmpeg_cmd += [output_m4b]
-
-        subprocess.run(ffmpeg_cmd, check=True)
-
-    chapter_files = sorted([os.path.join(input_dir, f) for f in os.listdir(input_dir) if f.endswith('.wav')], key=sort_key)
-    temp_dir = tempfile.gettempdir()
-    temp_combined_wav = os.path.join(temp_dir, 'combined.wav')
-    metadata_file = os.path.join(temp_dir, 'metadata.txt')
-    cover_image = extract_metadata_and_cover(ebook_file)
-    output_m4b = os.path.join(output_dir, os.path.splitext(os.path.basename(ebook_file))[0] + '.m4b')
-
-    combine_wav_files(chapter_files, temp_combined_wav)
-    generate_ffmpeg_metadata(chapter_files, metadata_file)
-    create_m4b(temp_combined_wav, metadata_file, cover_image, output_m4b)
-
-    if os.path.exists(temp_combined_wav):
-        os.remove(temp_combined_wav)
-    if os.path.exists(metadata_file):
-        os.remove(metadata_file)
-    if cover_image and os.path.exists(cover_image):
-        os.remove(cover_image)
-
-def create_chapter_labeled_book(ebook_file_path):
-    def ensure_directory(directory_path):
-        if not os.path.exists(directory_path):
-            os.makedirs(directory_path)
-            print(f"Created directory: {directory_path}")
-
-    ensure_directory(os.path.join(".", 'Working_files', 'Book'))
-
-    def convert_to_epub(input_path, output_path):
-        try:
-            subprocess.run(['ebook-convert', input_path, output_path], check=True)
-        except subprocess.CalledProcessError as e:
-            print(f"An error occurred while converting the eBook: {e}")
-            return False
-        return True
-
-    def save_chapters_as_text(epub_path):
-        directory = os.path.join(".", "Working_files", "temp_ebook")
-        ensure_directory(directory)
-
-        book = epub.read_epub(epub_path)
-
-        previous_filename = ''
-        chapter_counter = 0
-
-        for item in book.get_items():
-            if item.get_type() == ebooklib.ITEM_DOCUMENT:
-                soup = BeautifulSoup(item.get_content(), 'html.parser')
-                text = soup.get_text()
-
-                if text.strip():
-                    if len(text) < 2300 and previous_filename:
-                        with open(previous_filename, 'a', encoding='utf-8') as file:
-                            file.write('\n' + text)
-                    else:
-                        previous_filename = os.path.join(directory, f"chapter_{chapter_counter}.txt")
-                        chapter_counter += 1
-                        with open(previous_filename, 'w', encoding='utf-8') as file:
-                            file.write(text)
-                            print(f"Saved chapter: {previous_filename}")
-
-    input_ebook = ebook_file_path
-    output_epub = os.path.join(".", "Working_files", "temp.epub")
-
-    if os.path.exists(output_epub):
-        os.remove(output_epub)
-        print(f"File {output_epub} has been removed.")
-    else:
-        print(f"The file {output_epub} does not exist.")
-
-    if convert_to_epub(input_ebook, output_epub):
-        save_chapters_as_text(output_epub)
-
-    # nltk.download('punkt')
-
-    def process_chapter_files(folder_path, output_csv):
-        with open(output_csv, 'w', newline='', encoding='utf-8') as csvfile:
-            writer = csv.writer(csvfile)
-            writer.writerow(['Text', 'Start Location', 'End Location', 'Is Quote', 'Speaker', 'Chapter'])
-
-            chapter_files = sorted(os.listdir(folder_path), key=lambda x: int(x.split('_')[1].split('.')[0]))
-            for filename in chapter_files:
-                if filename.startswith('chapter_') and filename.endswith('.txt'):
-                    chapter_number = int(filename.split('_')[1].split('.')[0])
-                    file_path = os.path.join(folder_path, filename)
-
-                    try:
-                        with open(file_path, 'r', encoding='utf-8') as file:
-                            text = file.read()
-                            if text:
-                                text = "NEWCHAPTERABC" + text
-                            sentences = nltk.tokenize.sent_tokenize(text)
-                            for sentence in sentences:
-                                start_location = text.find(sentence)
-                                end_location = start_location + len(sentence)
-                                writer.writerow([sentence, start_location, end_location, 'True', 'Narrator', chapter_number])
-                    except Exception as e:
-                        print(f"Error processing file {filename}: {e}")
-
-    folder_path = os.path.join(".", "Working_files", "temp_ebook")
-    output_csv = os.path.join(".", "Working_files", "Book", "Other_book.csv")
-
-    process_chapter_files(folder_path, output_csv)
-
-    def sort_key(filename):
-        match = re.search(r'chapter_(\d+)\.txt', filename)
-        return int(match.group(1)) if match else 0
-
-    def combine_chapters(input_folder, output_file):
-        os.makedirs(os.path.dirname(output_file), exist_ok=True)
-
-        files = [f for f in os.listdir(input_folder) if f.endswith('.txt')]
-        sorted_files = sorted(files, key=sort_key)
-
-        with open(output_file, 'w', encoding='utf-8') as outfile:
-            for i, filename in enumerate(sorted_files):
-                with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as infile:
-                    outfile.write(infile.read())
-                    if i < len(sorted_files) - 1:
-                        outfile.write("\nNEWCHAPTERABC\n")
-
-    input_folder = os.path.join(".", 'Working_files', 'temp_ebook')
-    output_file = os.path.join(".", 'Working_files', 'Book', 'Chapter_Book.txt')
-
-    combine_chapters(input_folder, output_file)
-
-    ensure_directory(os.path.join(".", "Working_files", "Book"))
-
-def convert_chapters_to_audio_espeak(chapters_dir, output_audio_dir, speed="170", pitch="50", voice="en"):
-    if not os.path.exists(output_audio_dir):
-        os.makedirs(output_audio_dir)
-
-    for chapter_file in sorted(os.listdir(chapters_dir)):
-        if chapter_file.endswith('.txt'):
-            match = re.search(r"chapter_(\d+).txt", chapter_file)
-            if match:
-                chapter_num = int(match.group(1))
-            else:
-                print(f"Skipping file {chapter_file} as it does not match the expected format.")
-                continue
-
-            chapter_path = os.path.join(chapters_dir, chapter_file)
-            output_file_name = f"audio_chapter_{chapter_num}.wav"
-            output_file_path = os.path.join(output_audio_dir, output_file_name)
-
-            with open(chapter_path, 'r', encoding='utf-8') as file:
-                chapter_text = file.read()
-                sentences = nltk.tokenize.sent_tokenize(chapter_text)
-                combined_audio = AudioSegment.empty()
-
-                for sentence in tqdm(sentences, desc=f"Chapter {chapter_num}"):
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_wav:
-                        subprocess.run(["espeak-ng", "-v", voice, "-w", temp_wav.name, f"-s{speed}", f"-p{pitch}", sentence])
-                        combined_audio += AudioSegment.from_wav(temp_wav.name)
-                        os.remove(temp_wav.name)
-
-                combined_audio.export(output_file_path, format='wav')
-                print(f"Converted chapter {chapter_num} to audio.")
-
-def convert_ebook_to_audio(ebook_file, speed, pitch, voice, progress=gr.Progress()):
-    ebook_file_path = ebook_file.name
-    working_files = os.path.join(".", "Working_files", "temp_ebook")
-    full_folder_working_files = os.path.join(".", "Working_files")
-    chapters_directory = os.path.join(".", "Working_files", "temp_ebook")
-    output_audio_directory = os.path.join(".", 'Chapter_wav_files')
-    remove_folder_with_contents(full_folder_working_files)
-    remove_folder_with_contents(output_audio_directory)
-
-    try:
-        progress(0.1, desc="Creating chapter-labeled book")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-
-    create_chapter_labeled_book(ebook_file_path)
-    audiobook_output_path = os.path.join(".", "Audiobooks")
-
-    try:
-        progress(0.3, desc="Converting chapters to audio")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-
-    convert_chapters_to_audio_espeak(chapters_directory, output_audio_directory, speed, pitch, voice.split()[0])
-
-    try:
-        progress(0.9, desc="Creating M4B from chapters")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-
-    create_m4b_from_chapters(output_audio_directory, ebook_file_path, audiobook_output_path)
-
-    m4b_filename = os.path.splitext(os.path.basename(ebook_file_path))[0] + '.m4b'
-    m4b_filepath = os.path.join(audiobook_output_path, m4b_filename)
-
-    try:
-        progress(1.0, desc="Conversion complete")
-    except Exception as e:
-        print(f"Error updating progress: {e}")
-    print(f"Audiobook created at {m4b_filepath}")
-    return f"Audiobook created at {m4b_filepath}", m4b_filepath
-
-def list_audiobook_files(audiobook_folder):
-    files = []
-    for filename in os.listdir(audiobook_folder):
-        if filename.endswith('.m4b'):
-            files.append(os.path.join(audiobook_folder, filename))
-    return files
-
-def download_audiobooks():
-    audiobook_output_path = os.path.join(".", "Audiobooks")
-    return list_audiobook_files(audiobook_output_path)
-
-def get_available_voices():
-    result = subprocess.run(['espeak-ng', '--voices'], stdout=subprocess.PIPE, text=True)
-    lines = result.stdout.splitlines()[1:]  # Skip the header line
-    voices = []
-    for line in lines:
-        parts = line.split()
-        if len(parts) > 1:
-            voice_name = parts[1]
-            description = ' '.join(parts[2:])
-            voices.append((voice_name, description))
-    return voices
-
-theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="blue",
-    neutral_hue="blue",
-    text_size=gr.themes.sizes.text_md,
-)
-
-# Gradio UI setup
-with gr.Blocks(theme=theme) as demo:
-    gr.Markdown(
-    """
-    # eBook to Audiobook Converter
-    
-    Convert your eBooks into audiobooks using eSpeak-NG.
-    """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=3):
-            ebook_file = gr.File(label="eBook File")
-            speed = gr.Slider(minimum=80, maximum=450, value=170, step=1, label="Speed")
-            pitch = gr.Slider(minimum=0, maximum=99, value=50, step=1, label="Pitch")
-            voices = get_available_voices()
-            voice_choices = [f"{voice} ({desc})" for voice, desc in voices]
-            voice_dropdown = gr.Dropdown(choices=voice_choices, label="Select Voice", value=voice_choices[0])
-
-    convert_btn = gr.Button("Convert to Audiobook", variant="primary")
-    output = gr.Textbox(label="Conversion Status")
-    audio_player = gr.Audio(label="Audiobook Player", type="filepath")
-    download_btn = gr.Button("Download Audiobook Files")
-    download_files = gr.File(label="Download Files", interactive=False)
-
-    convert_btn.click(
-        convert_ebook_to_audio,
-        inputs=[ebook_file, speed, pitch, voice_dropdown],
-        outputs=[output, audio_player]
-    )
-
-    download_btn.click(
-        download_audiobooks,
-        outputs=[download_files]
-    )
-
-demo.launch(share=True)

import_all_files.py

@@ -1,5 +0,0 @@
-import import_nltk_files
-
-import import_locally_stored_tts_model_files
-
-#import download_tos_agreed_file

import_locally_stored_tts_model_files.py

@@ -1,23 +0,0 @@
-import os
-import shutil
-
-print("Importing locally stored coqui tts models...")
-
-# Define the source directory and the destination base path
-tts_folder = "/home/user/app/Base_XTTS_Model"
-destination_base = '/home/user/.local/share/'
-
-# Define the destination path for the tts folder
-destination_path = os.path.join(destination_base, 'tts')
-
-# Move the entire tts folder
-if os.path.exists(tts_folder):
-    # Remove the destination folder if it exists
-    if os.path.exists(destination_path):
-        shutil.rmtree(destination_path)  # Remove the existing folder
-    shutil.move(tts_folder, destination_path)
-    print(f'Moved: {tts_folder} to {destination_path}')
-    print("Locally stored base coqui XTTS tts model imported!")
-    print(os.listdir('/home/user/.local/share/tts'))
-else:
-    print(f'Source path does not exist: {tts_folder}')

import_nltk_files.py

@@ -1,24 +0,0 @@
-import shutil
-import os
-
-try:
-    print("Importing nltk files...")
-
-    # Define source and destination paths
-    source_folder = '/home/user/app/nltk_data'
-    destination_folder = '/home/user/nltk_data'
-
-    # Ensure the destination folder exists, create if it doesn't
-    os.makedirs(destination_folder, exist_ok=True)
-
-    # Move the source folder to the destination
-    shutil.move(source_folder, destination_folder)
-
-    print(f"NLTK folder moved to {destination_folder}")
-
-except FileNotFoundError as fnf_error:
-    print(f"Error: Source folder not found. {fnf_error}")
-except PermissionError as perm_error:
-    print(f"Error: Permission denied. {perm_error}")
-except Exception as e:
-    print(f"An unexpected error occurred: {e}")

input_folder/test.txt

@@ -1,2 +0,0 @@
-this is a story about joe, joe was Joe... you could say
-Sometimes I go down to the river and just, idk eat sandwiches

mini_story_long - Drew.m4b

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:83fef2cb1249fafd74f313a56733cad359328e3312dd7a5e026f68b8e244c7a2
-size 9666050

nltk_data/tokenizers/punkt.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:51c3078994aeaf650bfc8e028be4fb42b4a0d177d41c012b6a983979653660ec
-size 13905355

nltk_data/tokenizers/punkt/PY3/README

@@ -1,98 +0,0 @@
-Pretrained Punkt Models -- Jan Strunk (New version trained after issues 313 and 514 had been corrected)
-
-Most models were prepared using the test corpora from Kiss and Strunk (2006). Additional models have
-been contributed by various people using NLTK for sentence boundary detection.
-
-For information about how to use these models, please confer the tokenization HOWTO:
-http://nltk.googlecode.com/svn/trunk/doc/howto/tokenize.html
-and chapter 3.8 of the NLTK book:
-http://nltk.googlecode.com/svn/trunk/doc/book/ch03.html#sec-segmentation
-
-There are pretrained tokenizers for the following languages:
-
-File                Language            Source                             Contents                Size of training corpus(in tokens)           Model contributed by
-=======================================================================================================================================================================
-czech.pickle        Czech               Multilingual Corpus 1 (ECI)        Lidove Noviny                   ~345,000                             Jan Strunk / Tibor Kiss
-                                                                           Literarni Noviny
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-danish.pickle       Danish              Avisdata CD-Rom Ver. 1.1. 1995     Berlingske Tidende              ~550,000                             Jan Strunk / Tibor Kiss
-                                        (Berlingske Avisdata, Copenhagen)  Weekend Avisen
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-dutch.pickle        Dutch               Multilingual Corpus 1 (ECI)        De Limburger                    ~340,000                             Jan Strunk / Tibor Kiss
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-english.pickle      English             Penn Treebank (LDC)                Wall Street Journal             ~469,000                             Jan Strunk / Tibor Kiss
-                    (American)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-estonian.pickle     Estonian            University of Tartu, Estonia       Eesti Ekspress                  ~359,000                             Jan Strunk / Tibor Kiss
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-finnish.pickle      Finnish             Finnish Parole Corpus, Finnish     Books and major national        ~364,000                             Jan Strunk / Tibor Kiss
-                                        Text Bank (Suomen Kielen           newspapers
-                                        Tekstipankki)
-                                        Finnish Center for IT Science
-                                        (CSC)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-french.pickle       French              Multilingual Corpus 1 (ECI)        Le Monde                        ~370,000                             Jan Strunk / Tibor Kiss
-                    (European)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-german.pickle       German              Neue Zürcher Zeitung AG            Neue Zürcher Zeitung            ~847,000                             Jan Strunk / Tibor Kiss
-                    (Switzerland)       CD-ROM
-                    (Uses "ss"
-                     instead of "ß")
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-greek.pickle        Greek               Efstathios Stamatatos              To Vima (TO BHMA)               ~227,000                             Jan Strunk / Tibor Kiss
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-italian.pickle      Italian             Multilingual Corpus 1 (ECI)        La Stampa, Il Mattino           ~312,000                             Jan Strunk / Tibor Kiss
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-norwegian.pickle    Norwegian           Centre for Humanities              Bergens Tidende                 ~479,000                             Jan Strunk / Tibor Kiss
-                    (Bokmål and         Information Technologies,
-                     Nynorsk)           Bergen
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-polish.pickle       Polish              Polish National Corpus             Literature, newspapers, etc.  ~1,000,000                             Krzysztof Langner
-                                        (http://www.nkjp.pl/)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-portuguese.pickle   Portuguese          CETENFolha Corpus                  Folha de São Paulo              ~321,000                             Jan Strunk / Tibor Kiss
-                    (Brazilian)         (Linguateca)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-slovene.pickle      Slovene             TRACTOR                            Delo                            ~354,000                             Jan Strunk / Tibor Kiss
-                                        Slovene Academy for Arts
-                                        and Sciences
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-spanish.pickle      Spanish             Multilingual Corpus 1 (ECI)        Sur                             ~353,000                             Jan Strunk / Tibor Kiss
-                    (European)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-swedish.pickle      Swedish             Multilingual Corpus 1 (ECI)        Dagens Nyheter                  ~339,000                             Jan Strunk / Tibor Kiss
-                                                                           (and some other texts)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-turkish.pickle      Turkish             METU Turkish Corpus                Milliyet                        ~333,000                             Jan Strunk / Tibor Kiss
-                                        (Türkçe Derlem Projesi)
-                                        University of Ankara
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-The corpora contained about 400,000 tokens on average and mostly consisted of newspaper text converted to
-Unicode using the codecs module.
-
-Kiss, Tibor and Strunk, Jan (2006): Unsupervised Multilingual Sentence Boundary Detection.
-Computational Linguistics 32: 485-525.
-
----- Training Code ----
-
-# import punkt
-import nltk.tokenize.punkt
-
-# Make a new Tokenizer
-tokenizer = nltk.tokenize.punkt.PunktSentenceTokenizer()
-
-# Read in training corpus (one example: Slovene)
-import codecs
-text = codecs.open("slovene.plain","Ur","iso-8859-2").read()
-
-# Train tokenizer
-tokenizer.train(text)
-
-# Dump pickled tokenizer
-import pickle
-out = open("slovene.pickle","wb")
-pickle.dump(tokenizer, out)
-out.close()
-
----------