Developer notes for myself before I forget them

[DrewThomasson]

##(FIXED AND ADDED TO REPO) figure out what's causing the Frankenstein books for larry77,

(FIXED AND ADDED TO REPO)better sentence splitter idea

cause I just thought of this as I was typing and I don't want to forget this lol

And I'll see if I can get a recursive sentence splitter that works better than the current to stop the awkward pauses in lists and such sometimes;

Where if the sentence is over 250 in length or the amount of pauses is in the sentence is more than the program can handle then it keeps on splitting it by the middle pause if there is if not then just the middle until every piece isn't and then it'll return the sentence splits,

[DrewThomasson]

(NOT GOOD GAVE UP, doesn't sound good, the cuts are too jarring when you remove/cut out the silence, )A possible way to combine the audio files and remove any silence between them

Gave this test remove silence code a visualization to compare the original and modified code

import tkinter as tk
from tkinter import filedialog
from pydub import AudioSegment, silence
import matplotlib.pyplot as plt
import numpy as np

def remove_silence(audio_path):
    # Load the audio file
    audio = AudioSegment.from_file(audio_path)

    # Detect non-silent chunks
    non_silent_audio_chunks = silence.detect_nonsilent(audio, min_silence_len=500, silence_thresh=audio.dBFS-70)

    # Start with an empty audio segment
    non_silent_audio = AudioSegment.empty()

    # Define crossfade duration in milliseconds
    crossfade_duration = 50  # Adjust this value as needed

    # Iterate through non-silent chunks and append them with crossfade
    for i, (start, end) in enumerate(non_silent_audio_chunks):
        segment = audio[start:end]
        if i == 0:
            non_silent_audio = segment
        else:
            non_silent_audio = non_silent_audio.append(segment, crossfade=crossfade_duration)

    # Return both the modified audio and the chunks for plotting
    return non_silent_audio, non_silent_audio_chunks



def plot_audio_files(original_audio, modified_audio, silence_chunks):
    # Convert audio data to numpy arrays for plotting
    original_samples = np.array(original_audio.get_array_of_samples())
    modified_samples = np.array(modified_audio.get_array_of_samples())

    plt.figure(figsize=(10, 6))

    # Original Audio with highlighted silence parts
    plt.subplot(2, 1, 1)
    plt.plot(original_samples, label='Original Audio')
    plt.title('Original Audio')
    plt.xlim([0, len(original_samples)])
    
    # Highlighting silence parts in the original audio
    sample_rate = original_audio.frame_rate
    for start, end in silence_chunks:
        start_sample = int(start * sample_rate / 1000)  # Convert from ms to sample index
        end_sample = int(end * sample_rate / 1000)  # Convert from ms to sample index
        plt.axvspan(start_sample, end_sample, color='red', alpha=0.5)

    # Modified Audio
    plt.subplot(2, 1, 2)
    plt.plot(modified_samples, label='Modified Audio')
    plt.title('Modified Audio')
    plt.xlim([0, len(modified_samples)])

    plt.tight_layout()
    plt.show()



def select_file_and_process():
    # Ask the user to select an audio file
    file_path = filedialog.askopenfilename()
    if file_path:
        modified_audio, silence_chunks = remove_silence(file_path)  # Updated to receive two values
        original_audio = AudioSegment.from_file(file_path)

        # Saving modified audio to file
        modified_file_path = file_path.rsplit(".", 1)[0] + "_modified.wav"
        modified_audio.export(modified_file_path, format="wav")

        # Plot original and modified audio for comparison, including silence chunks
        plot_audio_files(original_audio, modified_audio, silence_chunks)

        print(f"Modified audio saved to: {modified_file_path}")


def main():
    root = tk.Tk()
    root.title("Silence Remover")
    root.geometry("300x150")

    tk.Button(root, text="Select Audio File", command=select_file_and_process).pack(pady=20)

    root.mainloop()

if __name__ == "__main__":
    main()

[DrewThomasson]

((FIXED AND ADDED TO REPO))A script to replace the current long sentence splitting script, giving a better more even split between sentences:

#To replace replace the split_long_string script

# Function to split long sentence strings into parts
def split_long_sentence(sentence, max_length=250, max_pauses=10):
    """
    Recursively splits a sentence based on length or number of pauses.
    
    :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.
    """
    # Check if the sentence meets the splitting criteria
    if len(sentence) >= max_length or sentence.count(',') + sentence.count(';') + sentence.count('.') > max_pauses:
        # Find the best place to split the sentence (middle pause or just the middle)
        possible_splits = [i for i, char in enumerate(sentence) if char in ',;.']
        
        if possible_splits:
            # Find the closest split point to the middle
            middle_index = len(sentence) // 2
            closest_split = min(possible_splits, key=lambda x: abs(x - middle_index))
        else:
            # If no punctuation to split on, choose the middle of the sentence
            closest_split = len(sentence) // 2
        
        # Split the sentence
        first_half = sentence[:closest_split + 1].strip()
        second_half = sentence[closest_split + 1:].strip()
        
        # Recursively split each half if necessary
        return split_long_sentence(first_half, max_length, max_pauses) + split_long_sentence(second_half, max_length, max_pauses)
    else:
        # If the sentence doesn't need splitting, return it as a single element list
        return [sentence]