# @title Default title text #This will download the booknlp files using my huggingface backup import download_missing_booknlp_models print("Starting...") #This will print out all of the avalible voice actors in a numbered list #It will also tell if a voice actor has a fine tuned xtts model or not def list_available_voice_actors(): print("\nList of current voices available:") voice_actors = [va for va in os.listdir(voice_actors_folder) if va != "cond_latent_example" and va != ".DS_Store"] for idx, voice in enumerate(voice_actors, 1): voice_path = os.path.join(voice_actors_folder, voice) model_path = os.path.join(voice_path, "model") status = "" if os.path.exists(model_path) and os.path.isdir(model_path): required_files = ["config.json", "model.pth", "vocab.json_"] existing_files = os.listdir(model_path) if all(file in existing_files for file in required_files): status = " (Fine-tuned XTTS model available)" else: missing_files = [file for file in required_files if file not in existing_files] status = f" (Incomplete XTTS model: missing {', '.join(missing_files)})" print(f"{idx}. {voice}{status}") print() # Add an extra newline for better readability #this is code that will be used to turn numbers like 1,000 and in a txt file into 1000 go then booknlp doesnt make it weird and then when the numbers are generated it comes out fine import re def process_large_numbers_in_txt(file_path): # Read the contents of the file with open(file_path, 'r') as file: content = file.read() # Regular expression to match numbers with commas pattern = r'\b\d{1,3}(,\d{3})+\b' # Remove commas in numerical sequences modified_content = re.sub(pattern, lambda m: m.group().replace(',', ''), content) # Write the modified content back to the file with open(file_path, 'w') as file: file.write(modified_content) # Usage example #file_path = 'test_1.txt' # Replace with your actual file path #process_large_numbers_in_txt(file_path) #this code here will remove any blank text rows from the csv file import pandas as pd def remove_empty_text_rows(csv_file): # Read the CSV file data = pd.read_csv(csv_file) # Remove rows where the 'Text' column is empty or NaN data = data[data['Text'].notna() & (data['Text'] != '')] # Write the modified DataFrame back to the CSV file data.to_csv(csv_file, index=False) print(f"Rows with empty 'Text' column have been removed from {csv_file}") # Example usage #csv_file = 'path_to_your_csv_file.csv' # Replace with your CSV file path #remove_empty_text_rows(csv_file) #this code here will split book.csv file by the custom weird chapter deliminator for amachines to see import pandas as pd def process_and_split_csv(file_path, split_string): def split_text(text, split_string, original_row): # Split the text at the specified string and find the index of the split split_index = text.find(split_string) parts = text.split(split_string) new_rows = [] start_location = original_row['Start Location'] for index, part in enumerate(parts): new_row = original_row.copy() if index == 0: new_row['Text'] = part new_row['End Location'] = start_location + split_index else: new_row['Text'] = split_string + part new_row['Start Location'] = start_location + split_index new_row['End Location'] = start_location + split_index + len(split_string) + len(part) split_index += len(split_string) + len(part) # Update for the next part new_rows.append(new_row) return new_rows def process_csv(df, split_string): new_rows = [] for _, row in df.iterrows(): text = row['Text'] if isinstance(text, str) and split_string in text: new_rows.extend(split_text(text, split_string, row)) else: new_rows.append(row) return pd.DataFrame(new_rows) # Read the CSV file df = pd.read_csv(file_path) # Process the DataFrame new_df = process_csv(df, split_string) # Write the modified DataFrame back to the CSV file new_df.to_csv(file_path, index=False) # Example usage #file_path = 'Working_files/Book/book.csv' #split_string = 'NEWCHAPTERABC' #process_and_split_csv(file_path, split_string) #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 import shutil # 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('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 = "Working_files/temp_ebook" #Clean up the text chapter folders by wiping it before creating chapters for selected ebook. #Lazily done by just deleting the directly and everything in it. if os.path.exists(directory): shutil.rmtree(directory) 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 = '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() 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}") """ 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 = "Working_files/temp_ebook" # Replace with your folder path output_csv = 'Working_files/Book/Other_book.csv' process_chapter_files(folder_path, output_csv) 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 through all files in the folder for filename in os.listdir(folder_path): file_path = os.path.join(folder_path, filename) # Check if it's a file and not a directory if os.path.isfile(file_path): try: os.remove(file_path) print(f"Removed file: {file_path}") except Exception as e: print(f"Failed to remove {file_path}. Reason: {e}") else: print(f"Skipping directory: {file_path}") # Example usage # folder_to_wipe = 'Working_files/temp_ebook' # Replace with the path to your folder # wipe_folder(folder_to_wipe) 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') as outfile: for i, filename in enumerate(sorted_files): with open(os.path.join(input_folder, filename), 'r') as infile: 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 = 'Working_files/temp_ebook' output_file = 'Working_files/Book/Chapter_Book.txt' # Combine the chapters combine_chapters(input_folder, output_file) ensure_directory('Working_files/Book') #create_chapter_labeled_book() #this is the Booknlp book grabber code import os import subprocess import tkinter as tk from tkinter import filedialog, messagebox from epub2txt import epub2txt from booknlp.booknlp import BookNLP import nltk import re nltk.download('averaged_perceptron_tagger') epub_file_path = "" chapters = [] ebook_file_path = "" input_file_is_txt = False def convert_epub_and_extract_chapters(epub_path): # Regular expression to match the chapter lines in the output chapter_pattern = re.compile(r'Detected chapter: \* (.*)') # List to store the extracted chapter names chapter_names = [] # Start the conversion process and capture the output process = subprocess.Popen(['ebook-convert', epub_path, '/dev/null'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) # Read the output line by line for line in iter(process.stdout.readline, ''): print(line, end='') # You can comment this out if you don't want to see the output match = chapter_pattern.search(line) if match: chapter_names.append(match.group(1)) # Wait for the process to finish process.stdout.close() process.wait() return chapter_names def calibre_installed(): """Check if Calibre's ebook-convert tool is available.""" try: subprocess.run(['ebook-convert', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) return True except FileNotFoundError: print("""ERROR NO CALIBRE: running epub2txt convert version... It appears you dont have the calibre commandline tools installed on your, This will allow you to convert from any ebook file format: Calibre supports the following input formats: CBZ, CBR, CBC, CHM, EPUB, FB2, HTML, LIT, LRF, MOBI, ODT, PDF, PRC, PDB, PML, RB, RTF, SNB, TCR, TXT. If you want this feature please follow online instruction for downloading the calibre commandline tool. For Linux its: sudo apt update && sudo apt upgrade sudo apt install calibre """) return False def convert_with_calibre(file_path, output_format="txt"): """Convert a file using Calibre's ebook-convert tool.""" output_path = file_path.rsplit('.', 1)[0] + '.' + output_format subprocess.run(['ebook-convert', file_path, output_path]) return output_path import os import subprocess import sys def process_file_headless(): # Ask for the file path via command line while True: #file_path = input("Enter the file path of the ebook: ") gradio_input_file = sys.argv[1] file_path = gradio_input_file # Check if the file exists if os.path.isfile(file_path): # File exists, break out of the loop break else: print("File not found. Please try again.") ebook_file_path = file_path input_file_is_txt = file_path.lower().endswith('.txt') if not os.path.exists(file_path): print("File not found. Please check the path and try again.") return if file_path.lower().endswith(('.cbz', '.cbr', '.cbc', '.chm', '.epub', '.fb2', '.html', '.lit', '.lrf', '.mobi', '.odt', '.pdf', '.prc', '.pdb', '.pml', '.rb', '.rtf', '.snb', '.tcr')) and calibre_installed(): file_path = convert_with_calibre(file_path) elif file_path.lower().endswith('.epub') and not calibre_installed(): content = epub2txt(file_path) if not os.path.exists('Working_files'): os.makedirs('Working_files') file_path = os.path.join('Working_files', 'Book.txt') with open(file_path, 'w', encoding='utf-8') as f: f.write(content) elif not file_path.lower().endswith('.txt'): print("Selected file format is not supported or Calibre is not installed.") return # Now process the TXT file with BookNLP book_id = "Book" output_directory = os.path.join('Working_files', book_id) model_params = { "pipeline": "entity,quote,supersense,event,coref", "model": "big" } # Process large numbers in text file to prevent tokenization errors process_large_numbers_in_txt(file_path) booknlp = BookNLP("en", model_params) if calibre_installed(): create_chapter_labeled_book(file_path) booknlp.process('Working_files/Book/Chapter_Book.txt', output_directory, book_id) # Clean up temporary files if not input_file_is_txt: os.remove(file_path) print(f"Deleted file: {file_path} because it's not needed anymore after the ebook conversion to txt") else: booknlp.process(file_path, output_directory, book_id) print("Success, File processed successfully!") # To run the script from the command line if __name__ == "__main__": process_file_headless() import pandas as pd def filter_and_correct_quotes(file_path): with open(file_path, 'r', encoding='utf-8') as file: lines = file.readlines() corrected_lines = [] # Filter out lines with mismatched quotes for line in lines: if line.count('"') % 2 == 0: corrected_lines.append(line) with open(file_path, 'w', encoding='utf-8') as file: file.writelines(corrected_lines) print(f"Processed {len(lines)} lines.") print(f"Removed {len(lines) - len(corrected_lines)} problematic lines.") print(f"Wrote {len(corrected_lines)} lines back to the file.") if __name__ == "__main__": file_path = "Working_files/Book/Book.quotes" filter_and_correct_quotes(file_path) import pandas as pd import re import glob import os def process_files(quotes_file, tokens_file): skip_rows = [] while True: try: df_quotes = pd.read_csv(quotes_file, delimiter="\t", skiprows=skip_rows) break except pd.errors.ParserError as e: msg = str(e) match = re.search(r'at row (\d+)', msg) if match: problematic_row = int(match.group(1)) print(f"Skipping problematic row {problematic_row} in {quotes_file}") skip_rows.append(problematic_row) else: print(f"Error reading {quotes_file}: {e}") return df_tokens = pd.read_csv(tokens_file, delimiter="\t", on_bad_lines='skip', quoting=3) last_end_id = 0 nonquotes_data = [] for index, row in df_quotes.iterrows(): start_id = row['quote_start'] end_id = row['quote_end'] filtered_tokens = df_tokens[(df_tokens['token_ID_within_document'] > last_end_id) & (df_tokens['token_ID_within_document'] < start_id)] words_chunk = ' '.join([str(token_row['word']) for index, token_row in filtered_tokens.iterrows()]) words_chunk = words_chunk.replace(" n't", "n't").replace(" n’", "n’").replace("( ", "(").replace(" ,", ",").replace("gon na", "gonna").replace(" n’t", "n’t") words_chunk = re.sub(r' (?=[^a-zA-Z0-9\s])', '', words_chunk) if words_chunk: nonquotes_data.append([words_chunk, last_end_id, start_id, "False", "Narrator"]) last_end_id = end_id nonquotes_df = pd.DataFrame(nonquotes_data, columns=["Text", "Start Location", "End Location", "Is Quote", "Speaker"]) output_filename = os.path.join(os.path.dirname(quotes_file), "non_quotes.csv") nonquotes_df.to_csv(output_filename, index=False) print(f"Saved nonquotes.csv to {output_filename}") def main(): quotes_files = glob.glob('Working_files/**/*.quotes', recursive=True) tokens_files = glob.glob('Working_files/**/*.tokens', recursive=True) for q_file in quotes_files: base_name = os.path.splitext(os.path.basename(q_file))[0] matching_token_files = [t_file for t_file in tokens_files if os.path.splitext(os.path.basename(t_file))[0] == base_name] if matching_token_files: process_files(q_file, matching_token_files[0]) print("All processing complete!") if __name__ == "__main__": main() import pandas as pd import re import glob import os import nltk def process_files(quotes_file, entities_file): # Load the files df_quotes = pd.read_csv(quotes_file, delimiter="\t") df_entities = pd.read_csv(entities_file, delimiter="\t") character_info = {} def is_pronoun(word): tagged_word = nltk.pos_tag([word]) return 'PRP' in tagged_word[0][1] or 'PRP$' in tagged_word[0][1] def get_gender(pronoun): male_pronouns = ['he', 'him', 'his'] female_pronouns = ['she', 'her', 'hers'] if pronoun in male_pronouns: return 'Male' elif pronoun in female_pronouns: return 'Female' return 'Unknown' # Process the quotes dataframe for index, row in df_quotes.iterrows(): char_id = row['char_id'] mention = row['mention_phrase'] # Initialize character info if not already present if char_id not in character_info: character_info[char_id] = {"names": {}, "pronouns": {}, "quote_count": 0} # Update names or pronouns based on the mention_phrase if is_pronoun(mention): character_info[char_id]["pronouns"].setdefault(mention.lower(), 0) character_info[char_id]["pronouns"][mention.lower()] += 1 else: character_info[char_id]["names"].setdefault(mention, 0) character_info[char_id]["names"][mention] += 1 character_info[char_id]["quote_count"] += 1 # Process the entities dataframe for index, row in df_entities.iterrows(): coref = row['COREF'] name = row['text'] if coref in character_info: if is_pronoun(name): character_info[coref]["pronouns"].setdefault(name.lower(), 0) character_info[coref]["pronouns"][name.lower()] += 1 else: character_info[coref]["names"].setdefault(name, 0) character_info[coref]["names"][name] += 1 # Extract the most likely name and gender for each character for char_id, info in character_info.items(): most_likely_name = max(info["names"].items(), key=lambda x: x[1])[0] if info["names"] else "Unknown" most_common_pronoun = max(info["pronouns"].items(), key=lambda x: x[1])[0] if info["pronouns"] else None gender = get_gender(most_common_pronoun) if most_common_pronoun else 'Unknown' gender_suffix = ".M" if gender == 'Male' else ".F" if gender == 'Female' else ".?" info["formatted_speaker"] = f"{char_id}:{most_likely_name}{gender_suffix}" info["most_likely_name"] = most_likely_name info["gender"] = gender # Write the formatted data to quotes.csv output_filename = os.path.join(os.path.dirname(quotes_file), "quotes.csv") with open(output_filename, 'w', newline='') as outfile: fieldnames = ["Text", "Start Location", "End Location", "Is Quote", "Speaker"] writer = pd.DataFrame(columns=fieldnames) for index, row in df_quotes.iterrows(): char_id = row['char_id'] if not re.search('[a-zA-Z0-9]', row['quote']): print(f"Removing row with text: {row['quote']}") continue if character_info[char_id]["quote_count"] == 1: formatted_speaker = "Narrator" else: formatted_speaker = character_info[char_id]["formatted_speaker"] if char_id in character_info else "Unknown" new_row = {"Text": row['quote'], "Start Location": row['quote_start'], "End Location": row['quote_end'], "Is Quote": "True", "Speaker": formatted_speaker} #turn the new_row into a data frame new_row_df = pd.DataFrame([new_row]) # Concatenate 'writer' with 'new_row_df' writer = pd.concat([writer, new_row_df], ignore_index=True) writer.to_csv(output_filename, index=False) print(f"Saved quotes.csv to {output_filename}") def main(): # Use glob to get all .quotes and .entities files within the "Working_files" directory and its subdirectories quotes_files = glob.glob('Working_files/**/*.quotes', recursive=True) entities_files = glob.glob('Working_files/**/*.entities', recursive=True) # Pair and process .quotes and .entities files with matching filenames (excluding the extension) for q_file in quotes_files: base_name = os.path.splitext(os.path.basename(q_file))[0] matching_entities_files = [e_file for e_file in entities_files if os.path.splitext(os.path.basename(e_file))[0] == base_name] if matching_entities_files: process_files(q_file, matching_entities_files[0]) print("All processing complete!") if __name__ == "__main__": main() import pandas as pd import re import glob import os def process_files(quotes_file, tokens_file): # Load the files df_quotes = pd.read_csv(quotes_file, delimiter="\t") df_tokens = pd.read_csv(tokens_file, delimiter="\t", on_bad_lines='skip', quoting=3) last_end_id = 0 # Initialize the last_end_id to 0 nonquotes_data = [] # List to hold data for nonquotes.csv # Iterate through the quotes dataframe for index, row in df_quotes.iterrows(): start_id = row['quote_start'] end_id = row['quote_end'] # Get tokens between the end of the last quote and the start of the current quote filtered_tokens = df_tokens[(df_tokens['token_ID_within_document'] > last_end_id) & (df_tokens['token_ID_within_document'] < start_id)] # Build the word chunk #words_chunk = ' '.join([token_row['word'] for index, token_row in filtered_tokens.iterrows()]) words_chunk = ' '.join([str(token_row['word']) for index, token_row in filtered_tokens.iterrows()]) words_chunk = words_chunk.replace(" n't", "n't").replace(" n’", "n’").replace(" ’", "’").replace(" ,", ",").replace(" .", ".").replace(" n’t", "n’t") words_chunk = re.sub(r' (?=[^a-zA-Z0-9\s])', '', words_chunk) # Append data to nonquotes_data if words_chunk is not empty if words_chunk: nonquotes_data.append([words_chunk, last_end_id, start_id, "False", "Narrator"]) last_end_id = end_id # Update the last_end_id to the end_id of the current quote # Create a DataFrame for non-quote data nonquotes_df = pd.DataFrame(nonquotes_data, columns=["Text", "Start Location", "End Location", "Is Quote", "Speaker"]) # Write to nonquotes.csv output_filename = os.path.join(os.path.dirname(quotes_file), "non_quotes.csv") nonquotes_df.to_csv(output_filename, index=False) print(f"Saved nonquotes.csv to {output_filename}") def main(): # Use glob to get all .quotes and .tokens files within the "Working_files" directory and its subdirectories quotes_files = glob.glob('Working_files/**/*.quotes', recursive=True) tokens_files = glob.glob('Working_files/**/*.tokens', recursive=True) # Pair and process .quotes and .tokens files with matching filenames (excluding the extension) for q_file in quotes_files: base_name = os.path.splitext(os.path.basename(q_file))[0] matching_token_files = [t_file for t_file in tokens_files if os.path.splitext(os.path.basename(t_file))[0] == base_name] if matching_token_files: process_files(q_file, matching_token_files[0]) print("All processing complete!") if __name__ == "__main__": main() import pandas as pd import numpy as np # Read the CSV files quotes_df = pd.read_csv("Working_files/Book/quotes.csv") non_quotes_df = pd.read_csv("Working_files/Book/non_quotes.csv") # Concatenate the dataframes combined_df = pd.concat([quotes_df, non_quotes_df], ignore_index=True) # Convert 'None' to NaN combined_df.replace('None', np.nan, inplace=True) # Drop rows with NaN in 'Start Location' combined_df.dropna(subset=['Start Location'], inplace=True) # Convert the 'Start Location' column to integers combined_df["Start Location"] = combined_df["Start Location"].astype(int) # Sort by 'Start Location' sorted_df = combined_df.sort_values(by="Start Location") # Save to 'book.csv' sorted_df.to_csv("Working_files/Book/book.csv", index=False) #if booknlp came up with nothing then just use the other_book.csv file thank god i still have that code import os import tkinter as tk from tkinter import messagebox def is_single_line_file(filename): with open(filename, 'r') as file: return len(file.readlines()) <= 1 def copy_if_single_line(source_file, destination_file): if not os.path.isfile(source_file): return f"The source file '{source_file}' does not exist." elif is_single_line_file(destination_file): with open(source_file, 'r') as source: content = source.read() with open(destination_file, 'w') as dest: dest.write(content) ## Popup message #root = tk.Tk() #root.withdraw() # Hide the main window #messagebox.showinfo("Notification", "The 'book.csv' file was found to be empty, so all lines in the book will be said by the narrator.") #root.destroy() print(f"Notification:") print(f"The 'book.csv' file was found to be empty, so all lines in the book will be said by the narrator.") return f"File '{destination_file}' had only one line or was empty and has been filled with the contents of '{source_file}'." else: return f"File '{destination_file}' had more than one line, and no action was taken." source_file = 'Working_files/Book/Other_book.csv' destination_file = 'Working_files/Book/book.csv' result = copy_if_single_line(source_file, destination_file) print(result) #this is a clean up script to try to clean up the quotes.csv and non_quotes.csv files of any types formed by booknlp import pandas as pd import os import re def process_text(text): # Apply the rule to remove spaces before punctuation and other non-alphanumeric characters text = re.sub(r' (?=[^a-zA-Z0-9\s])', '', text) # Replace " n’t" with "n’t" text = text.replace(" n’t", "n’t").replace("[", "(").replace("]", ")").replace("gon na", "gonna").replace("—————–", "").replace(" n't", "n't") return text def process_file(filename): # Load the file df = pd.read_csv(filename) # Check if the "Text" column exists if "Text" in df.columns: # Apply the rules to the "Text" column df['Text'] = df['Text'].apply(lambda x: process_text(str(x))) # Save the processed data back to the file df.to_csv(filename, index=False) print(f"Processed and saved {filename}") else: print(f"Column 'Text' not found in {filename}") def main(): folder_path = "Working_files/Book/" files = ["non_quotes.csv", "quotes.csv", "book.csv"] for filename in files: full_path = os.path.join(folder_path, filename) if os.path.exists(full_path): process_file(full_path) else: print(f"File {filename} not found in {folder_path}") if __name__ == "__main__": main() #this code here will split the bookcsv file by the calibre chapter deliminators such if calibre is installed if calibre_installed(): process_and_split_csv("Working_files/Book/book.csv", 'NEWCHAPTERABC') remove_empty_text_rows("Working_files/Book/book.csv") #this will wipe the computer of any current audio clips from a previous session #but itll ask the user first import os import tkinter as tk from tkinter import messagebox def check_and_wipe_folder(directory_path): # Check if the directory exists if not os.path.exists(directory_path): print(f"The directory {directory_path} does not exist!") return # Check for .wav files in the directory wav_files = [f for f in os.listdir(directory_path) if f.endswith('.wav')] if wav_files: # If there are .wav files ## Initialize tkinter #root = tk.Tk() #root.withdraw() # Hide the main window ## Ask the user if they want to delete the files #response = messagebox.askyesno("Confirm Deletion", "Audio clips from a previous session have been found. Do you want to wipe them?") #root.destroy() # Destroy the tkinter instance response = input("Audio clips from a previous session have been found. Do you want to wipe them? (yes/no): ").strip().lower() if response == 'yes': # If the user types 'yes' # Iterate through files and delete them for filename in wav_files: file_path = os.path.join(directory_path, filename) try: os.remove(file_path) print(f"Deleted: {file_path}") except Exception as e: print(f"Failed to delete {file_path}. Reason: {e}") else: print("Wipe operation cancelled by the user.") else: print("No audio clips from a previous session were found.") # Usage check_and_wipe_folder("Working_files/generated_audio_clips/") from TTS.api import TTS import tkinter as tk from tkinter import ttk, scrolledtext, messagebox, simpledialog, filedialog import threading import pandas as pd import random import os import time import os import pandas as pd import random import shutil import torch import torchaudio import time import pygame import nltk from nltk.tokenize import sent_tokenize from TTS.tts.configs.xtts_config import XttsConfig from TTS.tts.models.xtts import Xtts nltk.download('punkt') # Ensure that nltk punkt is downloaded nltk.download('punkt', quiet=True) demo_text = "Imagine a world where endless possibilities await around every corner." # Load the CSV data csv_file="Working_files/Book/book.csv" data = pd.read_csv(csv_file) #voice actors folder voice_actors_folder ="tortoise/voices/" # Get the list of voice actors voice_actors = [va for va in os.listdir(voice_actors_folder) if va != "cond_latent_example" and va != ".DS_Store"] male_voice_actors = [va for va in voice_actors if va.endswith(".M") and va != ".DS_Store"] female_voice_actors = [va for va in voice_actors if va.endswith(".F") and va != ".DS_Store"] SILENCE_DURATION_MS = 750 # Dictionary to hold each character's selected language character_languages = {} models = TTS().list_models() #selected_tts_model = 'tts_models/multilingual/multi-dataset/xtts_v2' #I have to do this right now cause they made a weird change to coqui idk super weird the list models isnt working right now #so this will chekc if its a list isk man and if not then the bug is still there and itll apply the fix if isinstance(models, list): print("good it's a list I can apply normal code for model list") selected_tts_model = models[0] else: tts_manager = TTS().list_models() all_models = tts_manager.list_models() models = all_models selected_tts_model = models[0] # Map for speaker to voice actor speaker_voice_map = {} CHAPTER_KEYWORD = "CHAPTER" multi_voice_model1 ="tts_models/en/vctk/vits" multi_voice_model2 ="tts_models/en/vctk/fast_pitch" multi_voice_model3 ="tts_models/ca/custom/vits" #multi_voice_model_voice_list1 =speakers_list = TTS(multi_voice_model1).speakers #multi_voice_model_voice_list2 =speakers_list = TTS(multi_voice_model2).speakers #multi_voice_model_voice_list3 =speakers_list = TTS(multi_voice_model3).speakers multi_voice_model_voice_list1 = [] multi_voice_model_voice_list2 = [] multi_voice_model_voice_list3 = [] # Dictionary to hold the comboboxes references voice_comboboxes = {} fast_voice_clone_models = [model for model in models if "multi-dataset" not in model] # Creating a dictionary with specific values for the defined models fast_voice_clone_models_dict = { model: "p363" if model == multi_voice_model1 else "VCTK_p226" if model == multi_voice_model2 else "pep" if model == multi_voice_model3 else None for model in fast_voice_clone_models } def on_silence_duration_change(*args): """ Update the SILENCE_DURATION_MS based on the entry value. """ global SILENCE_DURATION_MS try: new_duration = int(silence_duration_var.get()) if new_duration >= 0: SILENCE_DURATION_MS = new_duration print(f"SILENCE_DURATION_MS changed to: {SILENCE_DURATION_MS}") else: raise ValueError except ValueError: messagebox.showerror("Invalid Input", "Please enter a valid non-negative integer.") def validate_integer(P): """ Validate if the entry is an integer. """ if P.isdigit() or P == "": return True else: messagebox.showerror("Invalid Input", "Please enter a valid integer.") return False def update_silence_duration(): """ Update the SILENCE_DURATION_MS based on the entry value. """ global SILENCE_DURATION_MS try: SILENCE_DURATION_MS = int(silence_duration_var.get()) except ValueError: messagebox.showerror("Invalid Input", "Please enter a valid integer.") def add_languages_to_csv(): df = pd.read_csv('Working_files/Book/book.csv') # Make sure to use your actual CSV file path if 'language' not in df.columns: # Map the 'Speaker' column to the 'language' column using the character_languages dictionary # The get method returns 'en' as a default value if the speaker is not found in the dictionary df['language'] = df['Speaker'].apply(lambda speaker: character_languages.get(speaker, 'en')) df.to_csv('Working_files/Book/book.csv', index=False) # Save the changes back to the CSV file print("Added language data to the CSV file.") def add_voice_actors_to_csv(): df = pd.read_csv(csv_file) if 'voice_actor' not in df.columns: df['voice_actor'] = df['Speaker'].map(speaker_voice_map) df.to_csv(csv_file, index=False) print(f"Added voice actor data to {csv_file}") def get_random_voice_for_speaker(speaker): selected_voice_actors = voice_actors # default to all voice actors if speaker.endswith(".M") and male_voice_actors: selected_voice_actors = male_voice_actors elif speaker.endswith(".F") and female_voice_actors: selected_voice_actors = female_voice_actors if not selected_voice_actors: # If list is empty, default to all voice actors selected_voice_actors = voice_actors return random.choice(selected_voice_actors) def get_random_voice_for_speaker_fast(speaker): selected_voice_actors = voice_actors # default to all voice actors male_voice_actors = {"p226", "p228","p229","p230","p231","p232","p233","p234","p236","p238","p239","p241","p251","p252","p253","p254","p255","p256","p258","p262","p264","p265","p266","p267","p269","p272","p279","p281","p282","p285","p286","p287","p292","p298","p299","p301","p302","p307","p312","p313","p317","p318","p326","p340"} female_voice_actors = {"p225","p227","p237","p240","p243","p244","p245","p246","p247","p248","p249","p250","p257","p259","p260","p261","p263","p268","p270","p271","p273","p274","p275","p276","p277","p280","p283","p284","p288","p293","p294","p295","p297","p300","p303","p304","p305","p306","p308","p310","p311","p314","p316","p323","p329","p341","p343","p345","p347","p351","p360","p361","p362","p363","p364","p374"} if speaker.endswith(".M") and male_voice_actors: selected_voice_actors = male_voice_actors elif speaker.endswith(".F") and female_voice_actors: selected_voice_actors = female_voice_actors elif speaker.endswith(".?") and female_voice_actors: selected_voice_actors = male_voice_actors.union(female_voice_actors) if not selected_voice_actors: # If list is empty, default to all voice actors selected_voice_actors = male_voice_actors.union(female_voice_actors) # Convert the set to a list before using random.choice return random.choice(list(selected_voice_actors)) def ensure_output_folder(): if not os.path.exists("Working_files/generated_audio_clips"): os.mkdir("Working_files/generated_audio_clips") def ensure_temp_folder(): if not os.path.exists("Working_files/temp"): os.mkdir("Working_files/temp") import random import time def select_voices(): global speaker_voice_map random.seed(int(time.time())) ensure_output_folder() total_rows = len(data) # Assuming 'data' contains your dataset with a 'Speaker' column # Assign initial random voices speaker_voice_map = {speaker: get_random_voice_for_speaker(speaker) for speaker in data['Speaker'].unique()} # Function to display current voice selections and offer changes def review_and_modify_speaker_voices(): while True: # Display current selections print("\nCurrent voice selections:") for index, (speaker, voice) in enumerate(speaker_voice_map.items(), start=1): print(f"{index}. {speaker}: {voice}") # Ask if user wants to change any selection change = input("Would you like to change any voice assignments? (yes/no): ").lower() if change != 'yes': break # Get user input for which speaker to change try: selection = int(input("Enter the number of the speaker to change the voice for: ")) - 1 if selection < 0 or selection >= len(speaker_voice_map): raise ValueError("Selection out of range.") selected_speaker = list(speaker_voice_map.keys())[selection] except ValueError as e: print(f"Invalid input: {e}") continue # Display available voices and allow user to choose print(f"Available voices for {selected_speaker}:") if selected_speaker.endswith(".M") and male_voice_actors: available_voices = male_voice_actors elif selected_speaker.endswith(".F") and female_voice_actors: available_voices = female_voice_actors else: available_voices = voice_actors for idx, voice in enumerate(available_voices, start=1): print(f"{idx}. {voice}") try: new_voice_selection = int(input("Select the new voice by number: ")) - 1 if new_voice_selection < 0 or new_voice_selection >= len(available_voices): raise ValueError("Selection out of range.") # Update the speaker's voice in the map speaker_voice_map[selected_speaker] = available_voices[new_voice_selection] print(f"Voice for {selected_speaker} changed to {available_voices[new_voice_selection]}") except ValueError as e: print(f"Invalid input: {e}") review_and_modify_speaker_voices() print("Final voice assignments have been set.") def select_voices_fast(): random.seed(int(time.time())) ensure_output_folder() total_rows = len(data) for speaker in data['Speaker'].unique(): random_voice = get_random_voice_for_speaker_fast(speaker) speaker_voice_map[speaker] = random_voice for speaker, voice in speaker_voice_map.items(): print(f"Selected voice for {speaker}: {voice}") # Update the comboboxes if they exist if speaker in voice_comboboxes: random_voice = get_random_voice_for_speaker_fast(speaker) voice_comboboxes[speaker].set(random_voice) print("Voices have been selected randomly.") # Pre-select the voices before starting the GUI #select_voices() ## Main application window #root = tk.Tk() #root.title("coqui TTS GUI") #root.geometry("1200x800") #if calibre_installed(): # chapter_delimiter_var = tk.StringVar(value="NEWCHAPTERABC") #else: # chapter_delimiter_var = tk.StringVar(value="CHAPTER") # Assume calibre_installed is a function that returns True if Calibre is installed, otherwise False class Delimiter: def __init__(self, value): self._value = value self._callbacks = [] def get(self): return self._value def set(self, new_value): self._value = new_value self._run_callbacks() def _run_callbacks(self): for callback in self._callbacks: callback() def trace_add(self, mode, callback): if mode == "write": self._callbacks.append(callback) def update_chapter_keyword(): print("Chapter delimiter updated to:", chapter_delimiter_var.get()) if calibre_installed(): chapter_delimiter_var = Delimiter("NEWCHAPTERABC") else: chapter_delimiter_var = Delimiter("CHAPTER") # Initialize the mixer module try: pygame.mixer.init() print("mixer modual initialized successfully.") except pygame.error: print("mixer modual initialization failed") print(pygame.error) # This function is called when a voice actor is selected from the dropdown def update_voice_actor(speaker): selected_voice_actor = voice_comboboxes[speaker].get() speaker_voice_map[speaker] = selected_voice_actor print(f"Updated voice for {speaker}: {selected_voice_actor}") # Get a random reference file for the selected voice actor reference_files = list_reference_files(selected_voice_actor) if reference_files: # Check if there are any reference files random_file = random.choice(reference_files) try: # Stop any currently playing music or sound pygame.mixer.music.stop() pygame.mixer.stop() if random_file.endswith('.mp3'): # Use the music module for mp3 files pygame.mixer.music.load(random_file) pygame.mixer.music.play() else: # Use the Sound class for wav files sound = pygame.mixer.Sound(random_file) sound.play() except Exception as e: print(f"Could not play the audio file: {e}") # Function to split long strings into parts def split_long_sentence(sentence, max_length=220, max_pauses=8): """ 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 def combine_wav_files(input_directory, output_directory, file_name): # Get a list of all .wav files in the specified input directory input_file_paths = [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith(".wav")] # Sort the file paths to ensure numerical order input_file_paths.sort(key=lambda f: int(''.join(filter(str.isdigit, f)))) # Create an empty list to store the loaded audio tensors audio_tensors = [] # Iterate through the sorted input file paths and load each audio file for input_file_path in input_file_paths: waveform, sample_rate = torchaudio.load(input_file_path) audio_tensors.append(waveform) # Concatenate the audio tensors along the time axis (dimension 1) combined_audio = torch.cat(audio_tensors, dim=1) # 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) # Save the combined audio to the output file path torchaudio.save(output_file_path, combined_audio, sample_rate) print(f"Combined audio saved to {output_file_path}") def wipe_folder(directory_path): # Ensure the directory exists if not os.path.exists(directory_path): print(f"The directory {directory_path} does not exist!") return # Iterate through files in the directory for filename in os.listdir(directory_path): file_path = os.path.join(directory_path, filename) # Check if it's a regular file (not a subdirectory) if os.path.isfile(file_path): try: os.remove(file_path) print(f"Deleted: {file_path}") except Exception as e: print(f"Failed to delete {file_path}. Reason: {e}") # List of available TTS models tts_models = [ #'tts_models/multilingual/multi-dataset/xtts_v2', # Add all other models here... ] tts_models = TTS().list_models() #This is another coqui bug fix i have to apply for the bug idk why but nwo there this lol it started in coqui V0.22.0 #this will make the models list actually work tho if isinstance(tts_models, list): print("good it's a list I can apply normal code for model list") selected_tts_model = models[0] else: tts_manager = TTS().list_models() all_models = tts_manager.list_models() tts_models = all_models # Function to update the selected TTS model def update_tts_model(event): global selected_tts_model selected_tts_model = tts_model_combobox.get() print(f"Selected TTS model: {selected_tts_model}") multilingual_tts_models = [model for model in tts_models if "multi-dataset" in model] multilingual_tts_models.append('StyleTTS2') # modelse to be removed because i found that they are multi speaker and not single speaker models_to_remove = [multi_voice_model1, multi_voice_model2, multi_voice_model3] # List comprehension to remove the unwatned models multilingual_tts_models = [model for model in multilingual_tts_models if model not in models_to_remove] # Declare the button as global to access it in other functions global select_voices_button def update_voice_comboboxes(): global multi_voice_model_voice_list1 global multi_voice_model_voice_list2 global multi_voice_model_voice_list3 global voice_actors global female_voice_actors global male_voice_actors #updating the values of the avalible voice actors too voice_actors = [va for va in os.listdir(voice_actors_folder) if va != "cond_latent_example" and va != ".DS_Store"] male_voice_actors = [va for va in voice_actors if va.endswith(".M") and va != ".DS_Store"] female_voice_actors = [va for va in voice_actors if va.endswith(".F") and va != ".DS_Store"] # your code snippet to include single voice models filtered_tts_models = [model for model in tts_models if "multi-dataset" not in model] if not multi_voice_model_voice_list1: # This is True if the list is empty print(f"{multi_voice_model_voice_list1} is empty populating it...") multi_voice_model_voice_list1 = TTS(multi_voice_model1).speakers if not multi_voice_model_voice_list2: # This is True if the list is empty print(f"{multi_voice_model_voice_list2} is empty populating it...") multi_voice_model_voice_list2 = TTS(multi_voice_model2).speakers if not multi_voice_model_voice_list3: # This is True if the list is empty print(f"{multi_voice_model_voice_list3} is empty populating it...") multi_voice_model_voice_list3 = TTS(multi_voice_model3).speakers combined_values = voice_actors + filtered_tts_models combined_values += multi_voice_model_voice_list1 + multi_voice_model_voice_list2 + multi_voice_model_voice_list3 #this will remove unwatned models from the model list, thats cause these three are multi-speaker so im already including them as their voices combined_values.remove(multi_voice_model1) combined_values.remove(multi_voice_model2) combined_values.remove(multi_voice_model3) # Now update each combobox with the new combined_values for speaker, combobox in voice_comboboxes.items(): combobox['values'] = combined_values combobox.set(speaker_voice_map[speaker]) # Reset to the currently selected voice actor longest_string_length = max((len(str(value)) for value in combobox['values']), default=0) combobox.config(width=longest_string_length) # Filter models that are not 'multi-dataset' filtered_tts_models = [model for model in tts_models if "multi-dataset" not in model] # Extend the model list with filtered models multilingual_tts_models.extend(filtered_tts_models) # Set default value if needed #tts_model_combobox.set(selected_tts_model) ## Create a frame for the checkboxes #checkbox_frame = ttk.Frame(root) #checkbox_frame.pack(fill='x', pady=10) # Call this function once initially to set the correct values from the start update_voice_comboboxes() def create_folder_if_not_exists(folder_path): if not os.path.exists(folder_path): os.makedirs(folder_path) print(f"Folder '{folder_path}' created successfully.") else: print(f"Folder '{folder_path}' already exists.") #i want to gigv ethis the voice actor name and have it turn that into the full directory of the voice actor location, and then use that to grab all the files inside of that voice actoers folder def list_reference_files(voice_actor): global multi_voice_model_voice_list1 global multi_voice_model_voice_list2 global multi_voice_model_voice_list3 if voice_actor in multi_voice_model_voice_list1: create_folder_if_not_exists(f"tortoise/_model_demo_voices/{multi_voice_model1}/{voice_actor}") reference_files = [os.path.join(f"tortoise/_model_demo_voices/{multi_voice_model1}/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{multi_voice_model1}/{voice_actor}") if file.endswith((".wav", ".mp3"))] if len(reference_files)==0: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") fast_tts = TTS(multi_voice_model1, progress_bar=True).to(device) fast_tts.tts_to_file(text=demo_text , file_path=f"tortoise/_model_demo_voices/{multi_voice_model1}/{voice_actor}/demo.wav", speaker = voice_actor) reference_files = [os.path.join(f"tortoise/_model_demo_voices/{multi_voice_model1}/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{multi_voice_model1}/{voice_actor}") if file.endswith((".wav", ".mp3"))] return reference_files else: return reference_files elif voice_actor in multi_voice_model_voice_list2: create_folder_if_not_exists(f"tortoise/_model_demo_voices/{multi_voice_model2}/{voice_actor}") reference_files = [os.path.join(f"tortoise/_model_demo_voices/{multi_voice_model2}/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{multi_voice_model2}/{voice_actor}") if file.endswith((".wav", ".mp3"))] if len(reference_files)==0: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") fast_tts = TTS(multi_voice_model2, progress_bar=True).to("cpu") fast_tts.tts_to_file(text=demo_text , file_path=f"tortoise/_model_demo_voices/{multi_voice_model2}/{voice_actor}/demo.wav", speaker = voice_actor) reference_files = [os.path.join(f"tortoise/_model_demo_voices/{multi_voice_model2}/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{multi_voice_model2}/{voice_actor}") if file.endswith((".wav", ".mp3"))] return reference_files else: return reference_files elif voice_actor in multi_voice_model_voice_list3: create_folder_if_not_exists(f"tortoise/_model_demo_voices/{multi_voice_model3}/{voice_actor}") reference_files = [os.path.join(f"tortoise/_model_demo_voices/{multi_voice_model3}/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{multi_voice_model3}/{voice_actor}") if file.endswith((".wav", ".mp3"))] if len(reference_files)==0: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") fast_tts = TTS(multi_voice_model3, progress_bar=True).to(device) fast_tts.tts_to_file(text=demo_text , file_path=f"tortoise/_model_demo_voices/{multi_voice_model3}/{voice_actor}/demo.wav", speaker = voice_actor) reference_files = [os.path.join(f"tortoise/_model_demo_voices/{multi_voice_model3}/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{multi_voice_model3}/{voice_actor}") if file.endswith((".wav", ".mp3"))] return reference_files else: return reference_files elif "tts_models" in voice_actor: create_folder_if_not_exists("tortoise/_model_demo_voices") create_folder_if_not_exists(f"tortoise/_model_demo_voices/{voice_actor}") reference_files = [os.path.join(f"tortoise/_model_demo_voices/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{voice_actor}") if file.endswith((".wav", ".mp3"))] if len(reference_files)==0: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") fast_tts = TTS(voice_actor, progress_bar=True).to(device) fast_tts.tts_to_file(text=demo_text , file_path=f"tortoise/_model_demo_voices/{voice_actor}/demo.wav") reference_files = [os.path.join(f"tortoise/_model_demo_voices/{voice_actor}", file) for file in os.listdir(f"tortoise/_model_demo_voices/{voice_actor}") if file.endswith((".wav", ".mp3"))] return reference_files else: return reference_files single_voice_actor_folder = f"{voice_actors_folder}{voice_actor}/" # List all .wav and .mp3 files in the folder reference_files = [os.path.join(single_voice_actor_folder, file) for file in os.listdir(single_voice_actor_folder) if file.endswith((".wav", ".mp3"))] return reference_files # List of language codes and their display names 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' } # Variable to hold the current language selection, default to English current_language = 'en' current_model ="" tts = None STTS = None def generate_file_ids(csv_file, chapter_delimiter): data = pd.read_csv(csv_file) if 'audio_id' not in data.columns: data['audio_id'] = [''] * len(data) chapter_num = 0 for index, row in data.iterrows(): text = row['Text'] # Adjust to the correct column name, e.g., 'Text' if it's uppercase in the CSV print(f"{text}") if chapter_delimiter in text: # Ensure both are uppercase for case-insensitive matching/edit: nah chapter_num = chapter_num +1 data.at[index, 'audio_id'] = f"audio_{index}_{chapter_num}" data.to_csv(csv_file, index=False) print(f"'audio_id' column has been updated in {csv_file}") #delim = chapter_delimiter_var.get() generate_file_ids(csv_file, chapter_delimiter_var.get()) #function to generate audio for fine tuned speakers in xtts import os import torch import torchaudio from TTS.tts.configs.xtts_config import XttsConfig from TTS.tts.models.xtts import Xtts import time import sys from styletts2 import tts as stts # Function to install package using pip def install(package): subprocess.check_call([sys.executable, "-m", "pip", "install", package]) def fineTune_audio_generate(text, file_path, speaker_wav, language, voice_actor): global current_model global tts start_time = time.time() # Record the start time # Get device device = "cuda" if torch.cuda.is_available() else "cpu" # Add here the xtts_config path CONFIG_PATH = f"tortoise/voices/{voice_actor}/model/config.json" # Add here the vocab file that you have used to train the model TOKENIZER_PATH = f"tortoise/voices/{voice_actor}/model/vocab.json_" # Check for either vocab.json_ or vocab.json and rename if necessary vocab_path_with_underscore = f"tortoise/voices/{voice_actor}/model/vocab.json_" vocab_path_without_underscore = f"tortoise/voices/{voice_actor}/model/vocab.json" if os.path.exists(vocab_path_without_underscore): os.rename(vocab_path_without_underscore, vocab_path_with_underscore) print(f"Renamed {vocab_path_without_underscore} to {vocab_path_with_underscore}") elif not os.path.exists(vocab_path_with_underscore): raise FileNotFoundError("Neither vocab.json_ nor vocab.json found.") # Add here the checkpoint that you want to do inference with XTTS_CHECKPOINT = f"tortoise/voices/{voice_actor}/model/model.pth" # Add here the speaker reference SPEAKER_REFERENCE = speaker_wav # output wav path OUTPUT_WAV_PATH = file_path if current_model != voice_actor: print(f"found fine tuned for voice actor: {voice_actor}: loading custom model...") config = XttsConfig() config.load_json(CONFIG_PATH) if 'tts' not in locals(): tts = Xtts.init_from_config(config) tts.load_checkpoint(config, checkpoint_path=XTTS_CHECKPOINT, vocab_path=TOKENIZER_PATH, use_deepspeed=False) #make sure it runs on cpu or cuda depending on whats avalible on the machine if device == "cuda": tts.cuda() if device == "cpu": tts.cpu() current_model = voice_actor else: print(f"found fine tuned model for voice actor: {voice_actor} but {voice_actor} model is already loaded") print("Computing speaker latents...") gpt_cond_latent, speaker_embedding = tts.get_conditioning_latents(audio_path=[SPEAKER_REFERENCE]) print("Inference...") out = tts.inference( text, language, gpt_cond_latent, speaker_embedding, temperature=0.7, # Add custom parameters here ) torchaudio.save(OUTPUT_WAV_PATH, torch.tensor(out["wav"]).unsqueeze(0), 24000) end_time = time.time() # Record the end time elapsed_time = end_time - start_time print(f"Time taken for execution: {elapsed_time:.2f} seconds") def select_tts_model(): models = TTS().list_models() # Fetches all available TTS models additional_models = ["StyleTTS2"] # Manually add any special or last-minute models here all_models = models + additional_models # Combine lists current_model = all_models[0] # Default to the first model in the combined list while True: print(f"The TTS model currently selected is {current_model}.") response = input("Would you like to keep this model? (yes/no): ").strip().lower() if response == 'yes': return current_model elif response == 'no': print("Available models:") for model in all_models: print(model) while True: selected_model = input("Please type the name of one of the above models: ").strip() if selected_model in all_models: current_model = selected_model break else: print("Invalid model. Please select a model from the list.") else: print("Please answer 'yes' or 'no'.") #this code will have the user add a fine tuned xtts modela and also be able to clone a voice in the terminal without a gui import os import shutil from tkinter import filedialog def clone_new_voice(): while True: confirm = input("Do you want to clone a new voice? (yes/no): ").lower() if confirm == 'yes': voice_actor_name = input("Enter the name of the new voice actor: ") voice_actor_gender = input("Enter the gender of the new voice actor (M/F/?): ") new_voice_path = f"tortoise/voices/{voice_actor_name}.{voice_actor_gender}" if not os.path.exists(new_voice_path): os.makedirs(new_voice_path) print(f"New directory created at: {new_voice_path}") print("Please enter the path to the voice sample file to copy:") sample_file = input("Enter file path: ") if os.path.exists(sample_file): shutil.copy(sample_file, new_voice_path) print("Sample file copied successfully.") else: print("The file does not exist. Please check the path and try again.") else: print("Voice actor folder already exists.") repeat = input("Do you want to clone another new voice? (yes/no): ").lower() if repeat != 'yes': break elif confirm == 'no': break else: print("Please answer 'yes' or 'no'.") def add_fine_tuned_model(): while True: confirm = input("Do you want to add a fine-tuned XTTS model to a voice actor? (yes/no): ").lower() if confirm == 'yes': base_directory = "tortoise/voices/" folders = [folder for folder in os.listdir(base_directory) if os.path.isdir(os.path.join(base_directory, folder))] print("Select a voice actor to add a fine-tuned model to:") for index, folder in enumerate(folders): print(f"{index}: {folder}") selected_index = int(input("Enter the number corresponding to the voice actor: ")) selected_folder = folders[selected_index] model_path = os.path.join(base_directory, selected_folder, "model") if not os.path.exists(model_path): os.makedirs(model_path) print("Please enter the path to the folder containing fine-tuned XTTS model files to copy from:") source_folder = input("Enter folder path: ") if os.path.isdir(source_folder): for file in os.listdir(source_folder): source_file = os.path.join(source_folder, file) destination_file = os.path.join(model_path, file) shutil.copy2(source_file, destination_file) print(f"Files copied successfully to {model_path}") else: print("The specified directory does not exist. Please check the path and try again.") repeat = input("Do you want to add another fine-tuned model? (yes/no): ").lower() if repeat != 'yes': break elif confirm == 'no': break else: print("Please answer 'yes' or 'no'.") def ask_if_user_wants_to_add_fine_tuned_xtts_model_or_clone_a_voice(): while True: print("\n1. Clone a new voice") print("2. Add a fine-tuned XTTS model to a voice actor") print("3. Skip/Proceed to voice selection") choice = input("Enter your choice #: ") if choice == '1': clone_new_voice() list_available_voice_actors() # Update the list after cloning elif choice == '2': add_fine_tuned_model() list_available_voice_actors() # Update the list after adding a model elif choice == '3': print("Exiting the voice management menu.") break else: print("Invalid choice. Please try again.") #fucntion that will use the terminal to change the default language def select_language_terminal(): # Default language setting default_language = "en" language = default_language # Ask user to change the language change_lang = input(f"Do you want to change the language(Character accent) from {default_language}? (yes/no): ").strip().lower() if change_lang == "yes": # List available languages languages = ['en', 'es', 'fr', 'de', 'it', 'pt', 'pl', 'tr', 'ru', 'nl', 'cs', 'ar', 'zh-cn', 'hu', 'ko', 'ja', 'hi'] # Extend as needed print("Available languages:") for i, lang in enumerate(languages): print(f"{i + 1}. {lang}") # User selects the language while True: try: choice = int(input("Select a language by number: ")) language = languages[choice - 1] break except (IndexError, ValueError): print("Invalid selection. Please try again.") # Confirm the selection confirm = input(f"Confirm changing language to {language}? (yes/no): ").strip().lower() if confirm == "yes": print(f"Language set to {language}.") else: print("Language change canceled. Using default English.") language = default_language else: print("No language change requested. Using default English.") return language # Usage example #selected_language = select_language_terminal() #print(f"The selected language for TTS is: {selected_language}") from tqdm import tqdm # Function to generate audio for the text def generate_audio(): list_available_voice_actors() ask_if_user_wants_to_add_fine_tuned_xtts_model_or_clone_a_voice() select_voices() selected_tts_model = select_tts_model() #This will ask the user in the terminal if they want to generate all of the audio with only the narrerator's voice use_narrator_voice = input("Do you want to generate all audio with the Narrator voice? (yes/no): ").strip().lower() while use_narrator_voice not in ['yes', 'no']: print("Invalid input. Please type 'yes' or 'no'.") use_narrator_voice = input("Do you want to generate all audio with the Narrator voice? (yes/no): ").strip().lower() use_narrator_voice = use_narrator_voice == 'yes' global current_language current_language = select_language_terminal() # Get device start_timez = time.time() global multi_voice_model_voice_list1 global multi_voice_model_voice_list2 global multi_voice_model_voice_list3 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") global current_model global STTS ensure_temp_folder() # List available TTS models #print(TTS().list_models()) # Initialize the TTS model and set the device #tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device) # Update the model initialization to use the selected model #tts = TTS(selected_tts_model, progress_bar=True).to(device) #fast_tts = TTS(multi_voice_model1, progress_bar=True).to(device) random.seed(int(time.time())) ensure_output_folder() total_rows = len(data) chapter_num = 0 add_voice_actors_to_csv() add_languages_to_csv() for index, row in tqdm(data.iterrows(), total=data.shape[0], desc="Generating AudioBook"): #update_progress(index, total_rows) # Update progress based on the current index and total rows speaker = row['Speaker'] text = row['Text'] #update_progress(index, total_rows, text) # Update progress based on the current index and total rows and text language_code = character_languages.get(speaker, current_language) # Default to 'en' if not found if calibre_installed: if "NEWCHAPTERABC" in text: chapter_num += 1 print(f"chapter num: {chapter_num}") print(f"CHAPTER KEYWORD IS: NEWCHAPTERABC") text = text.replace("NEWCHAPTERABC", "") elif CHAPTER_KEYWORD in text.upper(): chapter_num += 1 print(f"chapter num: {chapter_num}") print(f"CHAPTER KEYWORD IS: {CHAPTER_KEYWORD}") #This is the code for grabbing the current voice actor #This will make it so that if the button for single voice is checked in the gui then the voice actor is always the narrerators: if use_narrator_voice: print(f"All audio is being generated with the Narrator voice.") voice_actor = speaker_voice_map.get("Narrator") else: voice_actor = speaker_voice_map[speaker] #voice_actor = speaker_voice_map[speaker] sentences = sent_tokenize(text) audio_tensors = [] temp_count =0 for sentence in sentences: fragments = split_long_sentence(sentence) for fragment in fragments: # Check if the selected model is multilingual if 'multilingual' in selected_tts_model: language_code = character_languages.get(speaker, current_language) else: language_code = None # No language specification for non-multilingual models print(f"Voice actor: {voice_actor}, {current_language}") temp_count = temp_count +1 # Use the model and language code to generate the audio #tts = TTS(model_name="tts_models/en/ek1/tacotron2", progress_bar=False).to(device) #tts.tts_to_file(fragment, speaker_wav=list_reference_files(voice_actor), progress_bar=True, file_path=f"Working_files/temp/{temp_count}.wav") #this will make it so that if your selecting a model as a voice actor name then itll initalize the voice actor name as the model if voice_actor in multi_voice_model_voice_list1: print(f"{voice_actor} is a fast model voice: {multi_voice_model1}") device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if current_model != multi_voice_model1: fast_tts = TTS(multi_voice_model1, progress_bar=True).to("cpu") current_model = multi_voice_model1 print(f"The model used in fast_tts has been changed to {current_model}") fast_tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker=voice_actor) elif voice_actor in multi_voice_model_voice_list2: print(f"{voice_actor} is a fast model voice: {multi_voice_model2}") if current_model != multi_voice_model2: fast_tts = TTS(multi_voice_model2, progress_bar=True).to("cpu") current_model = multi_voice_model2 print(f"The model used in fast_tts has been changed to {current_model}") fast_tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker=voice_actor) elif voice_actor in multi_voice_model_voice_list3: print(f"{voice_actor} is a fast model voice: {multi_voice_model3}") device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if current_model != multi_voice_model3: fast_tts = TTS(multi_voice_model3, progress_bar=True).to("cpu") current_model = multi_voice_model3 print(f"The model used in fast_tts has been changed to {current_model}") fast_tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker=voice_actor) elif "tts_models" in voice_actor and "multi-dataset" not in voice_actor: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if current_model != voice_actor: fast_tts = TTS(voice_actor, progress_bar=True).to(device) current_model = voice_actor print(f"The model used in fast_tts has been changed to {current_model}") #selected_tts_model = voice_actor #"Model is multi-lingual but no `language` is provided." print(f"Model for this character has been switched to: {voice_actor} by user") try: fast_tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav") except ValueError as e: if str(e) == "Model is multi-lingual but no `language` is provided.": print("attempting to correct....") fast_tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav",language=language_code) print("Successfully Corrected!") #else: # print(f"{voice_actor} is neither multi-dataset nor multilingual") # tts.tts_to_file(text=fragment,file_path=f"Working_files/temp/{temp_count}.wav") # Assuming the tts_to_file function has default arguments for unspecified parameters #If the voice actor has a custom fine tuned xtts model in its refrence folder ie if it has the model folder containing it elif os.path.exists(f"tortoise/voices/{voice_actor}/model") and os.path.isdir(f"tortoise/voices/{voice_actor}/model") and 'xtts' in selected_tts_model: speaker_wavz=list_reference_files(voice_actor) fineTune_audio_generate(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker_wav=speaker_wavz[0], language=language_code, voice_actor=voice_actor) # If the model contains both "multilingual" and "multi-dataset" elif "multilingual" in selected_tts_model and "multi-dataset" in selected_tts_model: if 'tts' not in locals(): tts = TTS(selected_tts_model, progress_bar=True).to(device) try: if "bark" in selected_tts_model: print(f"{selected_tts_model} is bark so multilingual but has no language code") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #tts = TTS(selected_tts_model, progress_bar=True).to(device) tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker_wav=list_reference_files(voice_actor)) else: print(f"{selected_tts_model} is multi-dataset and multilingual") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #tts = TTS(selected_tts_model, progress_bar=True).to(device) tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker_wav=list_reference_files(voice_actor), language=language_code) except ValueError as e: if str(e) == "Model is not multi-lingual but `language` is provided.": print("Caught ValueError: Model is not multi-lingual. Ignoring the language parameter.") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #tts = TTS(selected_tts_model, progress_bar=True).to(device) tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", speaker_wav=list_reference_files(voice_actor)) # If the model only contains "multilingual" elif "multilingual" in selected_tts_model: print(f"{selected_tts_model} is multilingual") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #tts = TTS(selected_tts_model, progress_bar=True).to(device) if 'tts' not in locals(): tts = TTS(selected_tts_model, progress_bar=True).to(device) tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav", language=language_code) # If the model only contains "multi-dataset" elif "multi-dataset" in selected_tts_model: print(f"{selected_tts_model} is multi-dataset") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #tts = TTS(selected_tts_model, progress_bar=True).to(device) if 'tts' not in locals(): tts = TTS(selected_tts_model, progress_bar=True).to(device) tts.tts_to_file(text=fragment, file_path=f"Working_files/temp/{temp_count}.wav") elif 'StyleTTS2' in selected_tts_model: print(f'{selected_tts_model} model is selected for voice cloning') if 'STTS' not in locals(): STTS = stts.StyleTTS2() STTS.inference(fragment, target_voice_path=list_reference_files(voice_actor)[0], output_wav_file=f"Working_files/temp/{temp_count}.wav") #if the model selected is one of the fast voice clone models as in not really voice clone but use voice transfer #right now im setting all of the fast voice cloning to be run on the cpu come can only be run on cpu and I'm lazy rn lol elif selected_tts_model in fast_voice_clone_models_dict: print(f"Using voice conversion voice cloning method and the selected model for this is {selected_tts_model}") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if current_model != selected_tts_model: if "tts" not in locals(): #tts = TTS(selected_tts_model).to(device) tts = TTS(selected_tts_model).to("cpu") current_model = selected_tts_model try: tts.tts_with_vc_to_file( fragment, speaker_wav=list_reference_files(voice_actor)[0], file_path=f"Working_files/temp/{temp_count}.wav", speaker=fast_voice_clone_models_dict[selected_tts_model] ) except Exception as e: print(f"An error occurred but was ignored: {e}") print("But continuing anyway but you should probs look at that error: its probably that the input for the tts model is too short so idk find a way to fix it if it runs into an issue like this:") # If the model contains neither "multilingual" nor "multi-dataset" else: print(f"{selected_tts_model} is neither multi-dataset nor multilingual") #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #tts = TTS(selected_tts_model, progress_bar=True).to(device) if 'tts' not in locals(): tts = TTS(selected_tts_model, progress_bar=True).to(device) tts.tts_to_file(text=fragment,file_path=f"Working_files/temp/{temp_count}.wav") # Assuming the tts_to_file function has default arguments for unspecified parameters temp_input_directory = "Working_files/temp" # Replace with the actual input directory path output_directory = "Working_files/generated_audio_clips" # Replace with the desired output directory path combine_wav_files(temp_input_directory, output_directory, f"audio_{index}_{chapter_num}.wav") wipe_folder("Working_files/temp") end_timez = time.time() durationz = end_timez - start_timez print("GENERATION TIME:" + str(durationz)) #root.destroy() from functools import partial def format_time(seconds): """ Formats time in seconds to a more readable string with minutes, hours, days, and years if applicable. """ minute = 60 hour = minute * 60 day = hour * 24 year = day * 365 years = seconds // year seconds %= year days = seconds // day seconds %= day hours = seconds // hour seconds %= hour minutes = seconds // minute seconds %= minute time_string = "" if years > 0: time_string += f"{years:.0f} year{'s' if years > 1 else ''} " if days > 0: time_string += f"{days:.0f} day{'s' if days > 1 else ''} " if hours > 0: time_string += f"{hours:.0f} hour{'s' if hours > 1 else ''} " if minutes > 0: time_string += f"{minutes:.0f} min " time_string += f"{seconds:.0f} sec" return time_string.strip() def update_progress(index, total, row_text): current_time = time.time() # Calculate elapsed time elapsed_time = current_time - start_time # Update total characters processed and count of processed rows global total_chars_processed, processed_rows_count total_chars_processed += len(row_text) processed_rows_count += 1 # Calculate progress progress = (index + 1) / total * 100 # Estimate remaining time if processed_rows_count > 0: # Avoid division by zero average_chars_per_row = total_chars_processed / processed_rows_count estimated_chars_remaining = average_chars_per_row * (total - processed_rows_count) average_time_per_char = elapsed_time / total_chars_processed estimated_time_remaining = average_time_per_char * estimated_chars_remaining remaining_time_string = format_time(estimated_time_remaining) else: remaining_time_string = "Calculating..." # Update progress label with estimated time progress_label.config(text=f"{progress:.2f}% done ({index+1}/{total} rows) - {remaining_time_string}") root.update_idletasks() # Start time capture and initialize counters start_time = time.time() total_chars_processed = 0 processed_rows_count = 0 def create_scrollable_frame(parent, height): # Create a canvas with a specific height canvas = tk.Canvas(parent, height=height) scrollbar = ttk.Scrollbar(parent, orient="vertical", command=canvas.yview) scrollable_frame = ttk.Frame(canvas) canvas.configure(yscrollcommand=scrollbar.set) canvas.create_window((0, 0), window=scrollable_frame, anchor="nw") scrollable_frame.bind( "", lambda e: canvas.configure(scrollregion=canvas.bbox("all")) ) canvas.pack(side="left", fill="both", expand=True) scrollbar.pack(side="right", fill="y") return scrollable_frame def update_chapter_keyword(*args): global CHAPTER_KEYWORD CHAPTER_KEYWORD = chapter_delimiter_var.get() # Add a trace to call update_chapter_keyword whenever the value changes chapter_delimiter_var.trace_add("write", update_chapter_keyword) ## Frame for Language Selection Dropdown #language_selection_frame = ttk.LabelFrame(root, text="Select TTS Language") #language_selection_frame.pack(fill="x", expand="yes", padx=10, pady=10) ## Create a dropdown for language selection #language_var = tk.StringVar() #language_combobox = ttk.Combobox(language_selection_frame, textvariable=language_var, state="readonly") #language_combobox['values'] = list(languages.keys()) # Use the display names for the user #language_combobox.set('English') # Set default value #def on_language_selected(event): # global current_language # # Update the current_language variable based on selection # current_language = languages[language_combobox.get()] # print(f"current language updated to: {current_language}") #language_combobox.bind("<>", on_language_selected) #language_combobox.pack(side="top", fill="x", expand="yes") #fuck ## Progress Bar #progress_var = tk.DoubleVar() #progress_bar = ttk.Progressbar(root, variable=progress_var, maximum=100) #progress_bar.pack() #progress_label = ttk.Label(root, text="0% done") #progress_label.pack() ## Create a frame to contain the buttons #buttons_frame = ttk.Frame(root) #buttons_frame.pack(pady=10) ## Generate Audio Button #generate_button = ttk.Button(buttons_frame, text="Generate Audio", command=lambda: threading.Thread(target=generate_audio).start()) #generate_button.pack(side=tk.LEFT, padx=5) #root.mainloop() generate_audio() #this code here will make sure the folder where all the chapter audio files go i whiped before it starts creating the chapter files cause there might be stuff from the last session import os import shutil def wipe_folder(folder_path): if os.path.exists(folder_path) and os.path.isdir(folder_path): print(f"Folder '{folder_path}' found. Proceeding to wipe...") shutil.rmtree(folder_path) print(f"Folder '{folder_path}' has been wiped.") else: print(f"Folder '{folder_path}' does not exist. No action taken.") # Usage folder_to_wipe = "Final_combined_output_audio" wipe_folder(folder_to_wipe) #this code here will combined all the tiny generated audio files into chapter audio files import os import pandas as pd import torch import torchaudio import pygame colors = ['#FFB6C1', '#ADD8E6', '#FFDAB9', '#98FB98', '#D8BFD8'] speaker_colors = {} currently_playing = None INPUT_FOLDER = "Working_files/generated_audio_clips" OUTPUT_FOLDER = "Final_combined_output_audio" #marked out cause its not defined earlier on in the code in the field #SILENCE_DURATION_MS = 0 try: pygame.mixer.init() print("mixer modual initialized successfully.") except pygame.error: print("mixer modual initialization failed") print(pygame.error) def combine_audio_files(silence_duration_ms): folder_path = os.path.join(os.getcwd(), INPUT_FOLDER) files = sorted([f for f in os.listdir(folder_path) if f.startswith("audio_") and f.endswith(".wav")], key=lambda f: (int(f.split('_')[2].split('.')[0]), int(f.split('_')[1].split('.')[0]))) chapter_files = {} for file in files: chapter_num = int(file.split('_')[2].split('.')[0]) if chapter_num not in chapter_files: chapter_files[chapter_num] = [] chapter_files[chapter_num].append(file) for chapter_num, chapter_file_list in chapter_files.items(): combined_tensor = torch.Tensor() for index, file in enumerate(chapter_file_list): waveform, sample_rate = torchaudio.load(os.path.join(folder_path, file)) channels = waveform.shape[0] silence_tensor = torch.zeros(channels, int(silence_duration_ms * sample_rate / 1000)) combined_tensor = torch.cat([combined_tensor, waveform, silence_tensor], dim=1) print(f"Processing Chapter {chapter_num} - File {index + 1}/{len(chapter_file_list)}: {file}") if not os.path.exists(os.path.join(os.getcwd(), OUTPUT_FOLDER)): os.makedirs(os.path.join(os.getcwd(), OUTPUT_FOLDER)) output_path = os.path.join(os.getcwd(), OUTPUT_FOLDER, f"chapter_{chapter_num}.wav") torchaudio.save(output_path, combined_tensor, sample_rate) print("Combining audio files complete!") combine_audio_files(SILENCE_DURATION_MS) #this code here will create the actual nicely formatted m4b file with chapters and image metadata and everything located at output audiobook import os import subprocess from pydub import AudioSegment import shlex def sort_chapters(file): # Extract chapter number from the filename number_part = re.findall(r'\d+', file) if number_part: return int(number_part[0]) return 0 def extract_ebook_metadata(ebook_file): try: metadata_cmd = ['ebook-meta', ebook_file] metadata_output = subprocess.run(metadata_cmd, capture_output=True, text=True).stdout metadata = {} # Extracting various metadata fields for line in metadata_output.splitlines(): if ':' in line: key, value = line.split(':', 1) metadata[key.strip()] = value.strip() # Extracting the cover image output_image = os.path.join('/tmp', os.path.basename(ebook_file) + '.jpg') subprocess.run(['ebook-meta', ebook_file, '--get-cover', output_image], check=True) if not os.path.exists(output_image): output_image = None return output_image, metadata except Exception as e: print(f"Error extracting eBook metadata: {e}") return None, {} def generate_chapter_metadata(wav_files, metadata_filename): with open(metadata_filename, 'w') as file: file.write(";FFMETADATA1\n") start_time = 0 for index, wav_file in enumerate(wav_files): duration = len(AudioSegment.from_wav(wav_file)) end_time = start_time + duration file.write(f"[CHAPTER]\nTIMEBASE=1/1000\nSTART={start_time}\nEND={end_time}\ntitle=Chapter {index+1:02d}\n") start_time = end_time def combine_wav_to_m4b_ffmpeg(wav_files, m4b_filename, cover_image, metadata_filename, metadata): print("Combining WAV files into an M4B audiobook using FFmpeg...") with open('file_list.txt', 'w') as file: for wav_file in wav_files: file.write(f"file '{shlex.quote(wav_file)}'\n") ffmpeg_cmd = f"ffmpeg -f concat -safe 0 -i file_list.txt -c copy combined.wav" ffmpeg_cmd += f" && ffmpeg -i combined.wav -i {shlex.quote(metadata_filename)}" if cover_image: ffmpeg_cmd += f" -i {shlex.quote(cover_image)}" for key, value in metadata.items(): ffmpeg_cmd += f" -metadata {key}=\"{value}\"" ffmpeg_cmd += f" -map_metadata 1" if cover_image: ffmpeg_cmd += f" -map 0 -map 2" ffmpeg_cmd += f" -c:a aac -b:a 192k" if cover_image: ffmpeg_cmd += f" -c:v copy -disposition:v:0 attached_pic" ffmpeg_cmd += f" {shlex.quote(m4b_filename)}" os.system(ffmpeg_cmd) print(f"M4B audiobook created: {m4b_filename}") # Cleanup os.remove('file_list.txt') if os.path.exists('combined.wav'): os.remove('combined.wav') os.remove(metadata_filename) if cover_image and os.path.exists(cover_image): os.remove(cover_image) def convert_all_wav_to_m4b(input_dir, ebook_file, output_dir, audiobook_name): if not os.path.exists(output_dir): os.makedirs(output_dir) print(f"Created output directory: {output_dir}") cover_image, ebook_metadata = extract_ebook_metadata(ebook_file) wav_files = [os.path.join(input_dir, f) for f in os.listdir(input_dir) if f.endswith('.wav')] wav_files.sort(key=sort_chapters) m4b_filename = os.path.join(output_dir, f'{audiobook_name}.m4b') metadata_filename = 'chapter_metadata.txt' # Setting up the metadata metadata = { 'artist': ebook_metadata.get('Author(s)', 'Unknown Author'), 'album': ebook_metadata.get('Series', 'Unknown Series'), 'Title': ebook_metadata.get('Title', f'{audiobook_name}.m4b'), 'date': ebook_metadata.get('Published', 'Unknown Year'), 'Genre': ebook_metadata.get('Tags', 'Unknown Genre'), 'Comment': ebook_metadata.get('Tags', 'No description available.'), # Add other metadata fields as needed } m4b_filename = ebook_metadata.get('Title', f"audiobook_name") m4b_filename = os.path.join(output_dir, f'{m4b_filename}.m4b') generate_chapter_metadata(wav_files, metadata_filename) combine_wav_to_m4b_ffmpeg(wav_files, m4b_filename, cover_image, metadata_filename, metadata) # Example usage input_dir = "Final_combined_output_audio" # Update this path to your WAV files folder ebook_file = ebook_file_path # Update this path to your eBook file output_dir = 'output_audiobooks' audiobook_name = os.path.splitext(os.path.basename(ebook_file))[0] # Update this path to your desired output directory convert_all_wav_to_m4b(input_dir, ebook_file, output_dir, audiobook_name) #this will convert all the audio files into a mp4 format instead of wav to save space #at the same time it will also delete the wav files as it converts them from moviepy.editor import * def convert_wav_to_mp4(wav_filename, mp4_filename): audio = AudioFileClip(wav_filename) audio.write_audiofile(mp4_filename, codec='aac') def convert_all_wav_to_mp4(): output_dir = "Final_combined_output_audio" wav_files = [f for f in os.listdir(output_dir) if f.endswith('.wav')] for wav_file in wav_files: wav_filename = os.path.join(output_dir, wav_file) mp4_filename = os.path.join(output_dir, wav_file.replace('.wav', '.mp4')) convert_wav_to_mp4(wav_filename, mp4_filename) print(f"{wav_filename} has been converted to {mp4_filename}.") os.remove(wav_filename) print(f"{wav_filename} as been deleted.") convert_all_wav_to_mp4() #this will add the cover of the epub file to the mp4 combined files print("Adding Book Artwork to mp4 chatper files if calibre is installed") import os import subprocess def extract_cover_image_calibre(ebook_file): """ Extracts the cover image from an eBook file using Calibre's ebook-meta tool. Args: ebook_file (str): The path to the eBook file. Returns: str: The path to the extracted cover image or None if not found. """ output_image = os.path.join('/tmp', os.path.basename(ebook_file) + '.jpg') try: subprocess.run(['ebook-meta', ebook_file, '--get-cover', output_image], check=True) if os.path.exists(output_image): return output_image else: return None except Exception as e: print(f"Error extracting cover image: {e}") return None def set_cover_to_mp4(cover_image, mp4_folder): """ Sets the extracted cover image to all mp4 files in a specified folder. Args: cover_image (str): The path to the cover image. mp4_folder (str): The path to the folder containing mp4 files. """ if not cover_image or not os.path.exists(cover_image): print("Cover image not found.") return # Process each mp4 file in the folder for file in os.listdir(mp4_folder): if file.lower().endswith('.mp4'): mp4_path = os.path.join(mp4_folder, file) # Set the cover image for the mp4 file # Note: Requires ffmpeg os.system(f'ffmpeg -i "{mp4_path}" -i "{cover_image}" -map 0 -map 1 -c copy -disposition:v:1 attached_pic "{mp4_path}.temp.mp4"') os.rename(f"{mp4_path}.temp.mp4", mp4_path) # Example usage ebook_file = ebook_file_path # Update this path to your eBook file mp4_folder = OUTPUT_FOLDER # Update this path to your MP4 folder #if calibre is installed then set the cover image things # Extract cover image from the eBook file cover_image = extract_cover_image_calibre(ebook_file) # Set cover image to all mp4 files in the specified folder set_cover_to_mp4(cover_image, mp4_folder)