barebones-tts 0.1.0__py3-none-any.whl

barebones_tts/__init__.py

@@ -0,0 +1,4 @@
+from .core import barebones_tts
+
+__all__ = ["barebones_tts"]
+__version__ = "0.1.0"

barebones_tts/__main__.py

@@ -0,0 +1,47 @@
+import argparse
+
+from colorama import init, Fore
+
+from .core import barebones_tts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="barebones-tts",
+        description="Text-to-speech from first principles.",
+    )
+    parser.add_argument(
+        "text",
+        nargs="*",
+        help="text to speak; if omitted, enters interactive mode",
+    )
+    parser.add_argument(
+        "-w", "--wav",
+        action="store_true",
+        help="also save the audio to a .wav file",
+    )
+    args = parser.parse_args()
+
+    init()
+    tts = barebones_tts()
+
+    if args.text:
+        input_text = " ".join(args.text)
+        tts.speak(input_text)
+        if args.wav:
+            tts.save(input_text)
+        return
+
+    try:
+        while True:
+            input_text = input(f"{Fore.GREEN}> ").strip()
+            tts.speak(input_text)
+
+            if args.wav:
+                tts.save(input_text)
+    except KeyboardInterrupt:
+        print(f"{Fore.RESET}\nGoodbye.")
+
+
+if __name__ == "__main__":
+    main()

barebones_tts/arpabet.py

@@ -0,0 +1,76 @@
+from .text_normalization import normalize_text
+from .tokenization import TokenList, Token
+from colorama import Fore
+from pickle import load
+from pathlib import Path
+
+DEFAULT_PRONUNCIATION_FILE = Path(__file__).parent / "data" / "pronunciation.pkl"
+
+class arpabet:
+    def __init__(self, pronunciation_file: str = str(DEFAULT_PRONUNCIATION_FILE)) -> None:
+        with open(pronunciation_file, mode='rb') as f:
+            self.PRONUNCIATIONS: dict[str, str] = load(f)
+        
+    def get_sound_from_db(self, TEXT: str) -> str | None:
+        if TEXT in self.PRONUNCIATIONS:
+            return self.PRONUNCIATIONS[TEXT]
+
+        return None
+
+
+    def fallback_pronunciation(self, TEXT: str) -> str:
+        CHARACTERS: list[str] = list(TEXT.strip())
+        output: list[str] = []
+
+        for CHARACTER in CHARACTERS:
+            sound = self.get_sound_from_db(CHARACTER.lower())
+            if sound:
+                output.append(sound)
+            else:
+                print(f"{Fore.RESET}{Fore.YELLOW}Unknown Character \"{CHARACTER.encode()}\"")
+
+        if output:
+            return " ".join(output).strip()
+        
+        return ""
+        
+
+
+    def arpabetize(self, tokens: TokenList, ) -> TokenList:
+        pronunciations: TokenList = TokenList()
+        for token in tokens:
+            if token.get_speakable_flag():
+                pronunciation_token: Token = Token()
+
+                TOKEN_TEXT = token.get_text().strip().lower()
+                
+                sound = self.get_sound_from_db(TOKEN_TEXT)
+                
+                if sound == None:
+                    sound = self.fallback_pronunciation(TOKEN_TEXT)
+
+                sound = sound.split()
+                pronunciation_token.set_text(TOKEN_TEXT)
+                pronunciation_token.set_phoneme(sound)
+                pronunciation_token.set_speakable_flag(True)
+                
+                pronunciations.append(pronunciation_token)
+            else:
+                pronunciations.append(token)
+
+
+        return pronunciations
+
+
+def main():
+    arpa = arpabet()
+    input_text = input('> ').strip()
+    normalized = normalize_text(input_text)
+    arpabetized = arpa.arpabetize(normalized)
+    
+
+    print(arpabetized)
+
+
+if __name__ == "__main__":
+    main()

barebones_tts/core.py

@@ -0,0 +1,95 @@
+from .text_normalization import normalize_text
+from .arpabet import arpabet
+from .formant_synth import FormantSynthesizer
+from colorama import Fore
+
+import numpy as np
+import re
+
+class barebones_tts:
+
+    def __init__(self) -> None:
+        self.synth = FormantSynthesizer()
+        self.arpabet = arpabet()
+
+
+    def sanitize_for_filename(self, input_string: str) -> str:
+        s = input_string.strip()
+        s = re.sub(r'[\s-]+', '_', s)
+        s = re.sub(r'[<>:"/\\|?*]', '', s)
+        s = s.strip('._')
+
+        if not s:
+            return "unnamed_file"
+
+        return s
+
+    def render(self, input_text: str) -> np.ndarray:
+
+        normalized = normalize_text(input_text)
+        print(f"{Fore.RESET}normalized: {Fore.CYAN}'{normalized}'")
+        arpabetized = self.arpabet.arpabetize(normalized)
+        print(f"{Fore.RESET}arpabetized: {Fore.YELLOW}'{arpabetized}'")
+
+        audios = []
+
+        for index, token in enumerate(arpabetized):
+            if token.get_speakable_flag():
+                TOKEN_PHONEME = token.get_phoneme()
+
+                audio = self.synth.synthesize(TOKEN_PHONEME)
+                silence = self.synth.generate_silence(100)
+                audio = np.concatenate([audio, silence])
+            elif token.get_modifies_previous_token_flag() and index > 0:
+
+                audios[index - 1] = self.synth.pitch_shift(audios[index - 1], token.get_pitch_modifier())
+                audio = self.synth.generate_silence(token.get_silence_time())
+            else:
+                audio = self.synth.generate_silence(token.get_silence_time())
+            audios.append(audio)
+
+        print(f"{Fore.RESET}{Fore.BLUE}Playing...")
+        complete_audio = np.concatenate(audios)
+        return complete_audio
+
+
+    def speak(self, input_text: str) -> None:
+        """
+        Wrapper around the `render()` function that speaks outloud the `input_text`.
+        
+        :param input_text: Text to be spoken
+        :type input_text: str
+        :param synth: Syntheizer object to use for synthesizing the phonemes into sound
+        :type synth: FormantSynthesizer
+        """
+
+        audio = self.render(input_text)
+        self.synth.play(audio)
+        
+
+    def save(self, input_text: str, filename: str = "") -> str:
+        """
+        Wrapper around the `render()` function that saves the `input_text` to a `wav` file.
+        
+        :param input_text: Text to be spoken
+        :type input_text: str
+        :param synth: Syntheizer object to use for synthesizing the phonemes into sound.
+        :type synth: FormantSynthesizer
+        :param filename: Filename of the new `wav` file. Will default to a sanitized version of the `input_text`.
+        :type filename: str
+
+        :return: Filename of newly created `wav` file.
+        :rtype: str
+        """
+        audio = self.render(input_text)
+
+        if filename == "":
+            filename = f'{self.sanitize_for_filename(input_text)}.wav'
+        
+        self.synth.save_wav(audio, filename)
+        return filename
+
+
+
+    
+

barebones_tts/formant_synth.py

@@ -0,0 +1,298 @@
+import numpy as np
+from scipy.io import wavfile
+from scipy import signal
+
+
+# Types: 'vowel', 'nasal', 'liquid', 'fricative', 'stop', 'affricate'
+PHONEME_DATA = {
+    # VOWELS
+    'AA': [730, 1090, 2440, 1.0, 0.7, 0.3, 0.15, 'vowel'],
+    'AE': [660, 1720, 2410, 1.0, 0.8, 0.3, 0.15, 'vowel'],
+    'AH': [640, 1190, 2390, 1.0, 0.7, 0.3, 0.12, 'vowel'],
+    'AO': [570, 840,  2410, 1.0, 0.6, 0.3, 0.15, 'vowel'],
+    'AW': [640, 1190, 2390, 1.0, 0.7, 0.3, 0.20, 'vowel'],
+    'AY': [730, 1090, 2440, 1.0, 0.7, 0.3, 0.20, 'vowel'],
+    'EH': [530, 1840, 2480, 1.0, 0.8, 0.3, 0.12, 'vowel'],
+    'ER': [490, 1350, 1690, 1.0, 0.7, 0.4, 0.15, 'vowel'],
+    'EY': [400, 2000, 2550, 1.0, 0.8, 0.3, 0.18, 'vowel'],
+    'IH': [390, 1990, 2550, 1.0, 0.8, 0.3, 0.10, 'vowel'],
+    'IY': [270, 2290, 3010, 1.0, 0.9, 0.4, 0.15, 'vowel'],
+    'OW': [500, 700,  2600, 1.0, 0.6, 0.3, 0.18, 'vowel'],
+    'OY': [570, 840,  2410, 1.0, 0.6, 0.3, 0.20, 'vowel'],
+    'UH': [440, 1020, 2240, 1.0, 0.6, 0.3, 0.12, 'vowel'],
+    'UW': [300, 870,  2240, 1.0, 0.6, 0.3, 0.15, 'vowel'],
+    
+    # NASALS 
+    'M':  [280, 1200, 2500, 0.9, 0.4, 0.2, 0.08, 'nasal'],
+    'N':  [280, 1700, 2600, 0.9, 0.4, 0.2, 0.07, 'nasal'],
+    'NG': [280, 2200, 2600, 0.9, 0.4, 0.2, 0.09, 'nasal'],
+    
+    # LIQUIDS 
+    'L':  [300, 1300, 3000, 0.8, 0.5, 0.3, 0.07, 'liquid'],
+    'R':  [420, 1300, 1600, 0.8, 0.5, 0.3, 0.08, 'liquid'],
+    
+    # SEMIVOWELS 
+    'W':  [300, 610,  2200, 0.8, 0.5, 0.3, 0.08, 'liquid'],
+    'Y':  [280, 2250, 3000, 0.8, 0.6, 0.3, 0.06, 'liquid'],
+    
+    # VOICED FRICATIVES 
+    'V':  [200, 1000, 2500, 0.3, 0.3, 0.3, 0.09, 'fricative', {'voiced': True, 'freq': 2000}],
+    'DH': [200, 1400, 2500, 0.3, 0.3, 0.3, 0.07, 'fricative', {'voiced': True, 'freq': 3500}],
+    'Z':  [200, 1500, 2500, 0.3, 0.4, 0.4, 0.10, 'fricative', {'voiced': True, 'freq': 5000}],
+    'ZH': [200, 1500, 2000, 0.3, 0.4, 0.4, 0.11, 'fricative', {'voiced': True, 'freq': 3000}],
+    
+    # UNVOICED FRICATIVES 
+    'F':  [200, 1000, 2500, 0.4, 0.4, 0.4, 0.10, 'fricative', {'voiced': False, 'freq': 2500}],
+    'TH': [200, 1400, 2500, 0.4, 0.4, 0.4, 0.09, 'fricative', {'voiced': False, 'freq': 4000}],
+    'S':  [200, 1500, 2500, 0.4, 0.5, 0.5, 0.12, 'fricative', {'voiced': False, 'freq': 6000}],
+    'SH': [200, 1500, 2000, 0.4, 0.5, 0.5, 0.12, 'fricative', {'voiced': False, 'freq': 3500}],
+    'HH': [200, 1500, 2500, 0.3, 0.3, 0.3, 0.08, 'fricative', {'voiced': False, 'freq': 2000}],
+    
+    # VOICED STOPS 
+    'B':  [200, 1000, 2500, 0.6, 0.4, 0.3, 0.08, 'stop', {'voiced': True, 'closure': 0.04, 'freq': 500}],
+    'D':  [200, 1700, 2500, 0.6, 0.4, 0.3, 0.07, 'stop', {'voiced': True, 'closure': 0.04, 'freq': 2000}],
+    'G':  [200, 2500, 3000, 0.6, 0.4, 0.3, 0.08, 'stop', {'voiced': True, 'closure': 0.05, 'freq': 2500}],
+    
+    # UNVOICED STOPS 
+    'P':  [200, 1000, 2500, 0.7, 0.5, 0.3, 0.09, 'stop', {'voiced': False, 'closure': 0.05, 'freq': 500}],
+    'T':  [200, 1700, 2500, 0.7, 0.5, 0.3, 0.08, 'stop', {'voiced': False, 'closure': 0.05, 'freq': 3000}],
+    'K':  [200, 2500, 3000, 0.7, 0.5, 0.3, 0.09, 'stop', {'voiced': False, 'closure': 0.06, 'freq': 3500}],
+    
+    # AFFRICATES 
+    'CH': [200, 1500, 2000, 0.6, 0.5, 0.4, 0.13, 'affricate', {'voiced': False, 'closure': 0.04, 'freq': 3500}],
+    'JH': [200, 1500, 2000, 0.6, 0.5, 0.4, 0.13, 'affricate', {'voiced': True, 'closure': 0.04, 'freq': 3000}],
+}
+
+class FormantSynthesizer:
+    def __init__(self, sample_rate=22050):
+        self.sample_rate = sample_rate
+        self.pitch = 120  # Hz
+        
+    def generate_glottal_pulse(self, duration):
+        num_samples = int(self.sample_rate * duration)
+        t = np.arange(num_samples) / self.sample_rate
+        
+        pulse_period = 1.0 / self.pitch
+        excitation = np.zeros(num_samples)
+        
+        pulse_samples = int(self.sample_rate * pulse_period)
+        pulse = np.zeros(pulse_samples)
+        
+        rise_len = int(pulse_samples * 0.4)
+        pulse[:rise_len] = np.linspace(0, 1, rise_len) ** 2
+        
+        fall_len = int(pulse_samples * 0.16)
+        pulse[rise_len:rise_len+fall_len] = np.linspace(1, 0, fall_len)
+        
+        num_pulses = int(duration / pulse_period) + 1
+        for i in range(num_pulses):
+            start = i * pulse_samples
+            end = min(start + pulse_samples, num_samples)
+            if start < num_samples:
+                excitation[start:end] = pulse[:end-start]
+            
+        return excitation
+    
+    def generate_noise(self, duration):
+        num_samples = int(self.sample_rate * duration)
+        return np.random.randn(num_samples)
+    
+    def highpass_filter(self, audio, cutoff=500):
+        nyquist = self.sample_rate / 2
+        normalized_cutoff = cutoff / nyquist
+        b, a = signal.butter(4, normalized_cutoff, btype='high')
+        return signal.filtfilt(b, a, audio)
+    
+    def bandpass_filter(self, audio, center_freq, bandwidth=1000):
+        nyquist = self.sample_rate / 2
+        low = max((center_freq - bandwidth/2) / nyquist, 0.01)
+        high = min((center_freq + bandwidth/2) / nyquist, 0.99)
+        b, a = signal.butter(3, [low, high], btype='band')
+        return signal.filtfilt(b, a, audio)
+    
+    def formant_filter(self, audio, frequency, bandwidth) -> float:
+        r = np.exp(-np.pi * bandwidth / self.sample_rate)
+        theta = 2 * np.pi * frequency / self.sample_rate
+        
+        a = [1.0, -2*r*np.cos(theta), r**2]
+        b = [1 - r**2]
+
+        FILTERED: float = signal.lfilter(b, a, audio)
+        
+        return FILTERED
+    
+    def synthesize_vowel(self, f1, f2, f3, amp1, amp2, amp3, duration):
+        excitation = self.generate_glottal_pulse(duration)
+        
+        audio = np.zeros_like(excitation)
+        audio += amp1 * self.formant_filter(excitation, f1, 60)
+        audio += amp2 * self.formant_filter(excitation, f2, 90)
+        audio += amp3 * self.formant_filter(excitation, f3, 120)
+        
+        return audio
+    
+    def synthesize_nasal(self, f1, f2, f3, amp1, amp2, amp3, duration):
+        excitation = self.generate_glottal_pulse(duration)
+        
+        audio = np.zeros_like(excitation)
+        audio += amp1 * self.formant_filter(excitation, f1, 100)
+        audio += amp2 * self.formant_filter(excitation, f2, 150)
+        audio += amp3 * self.formant_filter(excitation, f3, 200)
+        
+        audio += 0.3 * self.formant_filter(excitation, 250, 100)
+        
+        return audio
+    
+    def synthesize_fricative(self, f1, f2, f3, amp1, amp2, amp3, duration, voiced=False, freq=3000):
+        if voiced:
+            excitation = 0.3 * self.generate_glottal_pulse(duration) + \
+                        0.7 * self.generate_noise(duration)
+        else:
+            excitation = self.generate_noise(duration)
+        
+        audio = self.bandpass_filter(excitation, freq, 2000)
+        
+        audio += amp1 * 0.3 * self.formant_filter(excitation, f1, 200)
+        audio += amp2 * 0.3 * self.formant_filter(excitation, f2, 200)
+        
+        return audio
+    
+    def synthesize_stop(self, f1, f2, f3, amp1, amp2, amp3, duration, voiced=False, closure=0.05, freq=2000):
+        closure_samples = int(self.sample_rate * closure)
+        burst_duration = duration - closure
+        burst_samples = int(self.sample_rate * burst_duration)
+        
+        silence = np.zeros(closure_samples)
+        
+        short_burst_duration = min(burst_duration * 0.3, 0.03)  # Max 30ms
+        
+        if voiced:
+            burst = 0.5 * self.generate_glottal_pulse(short_burst_duration) + \
+                0.5 * self.generate_noise(short_burst_duration)
+        else:
+            burst = self.generate_noise(short_burst_duration)
+        
+        burst = np.pad(burst, (0, burst_samples - len(burst)))
+        
+        if len(burst) > 0:
+            burst = self.bandpass_filter(burst, freq, 2000)
+            envelope = np.exp(-np.linspace(0, 5, len(burst)))
+            burst = burst * envelope
+        
+        return np.concatenate([silence, burst])
+    
+    def synthesize_affricate(self, f1, f2, f3, amp1, amp2, amp3, duration, voiced=False, closure=0.04, freq=3000):
+        closure_samples = int(self.sample_rate * closure)
+        fric_duration = duration - closure
+        
+        silence = np.zeros(closure_samples)
+        
+        fricative = self.synthesize_fricative(f1, f2, f3, amp1, amp2, amp3,
+                                              fric_duration, voiced, freq)
+        
+        return np.concatenate([silence, fricative])
+    
+    def synthesize_phoneme(self, params):
+        f1, f2, f3, amp1, amp2, amp3, duration, ptype = params[:8]
+        extra = params[8] if len(params) > 8 else {}
+        
+        if ptype == 'vowel':
+            audio = self.synthesize_vowel(f1, f2, f3, amp1, amp2, amp3, duration)
+        elif ptype == 'nasal':
+            audio = self.synthesize_nasal(f1, f2, f3, amp1, amp2, amp3, duration)
+        elif ptype == 'liquid':
+            audio = self.synthesize_vowel(f1, f2, f3, amp1, amp2, amp3, duration)
+        elif ptype == 'fricative':
+            audio = self.synthesize_fricative(f1, f2, f3, amp1, amp2, amp3, duration, extra.get('voiced', False), extra.get('freq', 3000))
+        elif ptype == 'stop':
+            audio = self.synthesize_stop(f1, f2, f3, amp1, amp2, amp3, duration, extra.get('voiced', False), extra.get('closure', 0.05), extra.get('freq', 2000))
+        elif ptype == 'affricate':
+            audio = self.synthesize_affricate(f1, f2, f3, amp1, amp2, amp3, duration, extra.get('voiced', False), extra.get('closure', 0.04), extra.get('freq', 3000))
+        else:
+            audio = np.zeros(int(self.sample_rate * duration))
+        
+        fade_samples = min(int(0.005 * self.sample_rate), len(audio) // 4)
+        if fade_samples > 0 and len(audio) > 0:
+            envelope = np.ones(len(audio))
+            envelope[:fade_samples] = np.linspace(0, 1, fade_samples)
+            envelope[-fade_samples:] = np.linspace(1, 0, fade_samples)
+            audio = audio * envelope
+        
+        return audio
+    
+    def synthesize(self, phonemes):
+        audio_segments = []
+        
+        for i, phoneme in enumerate(phonemes):
+            # i'd like to eventually add lexical stress but i've no idea where to start for that
+            phoneme = phoneme.rstrip('012')
+            
+            if phoneme not in PHONEME_DATA:
+                print(f"Warning: Unknown phoneme '{phoneme}', adding silence")
+                audio_segments.append(np.zeros(int(self.sample_rate * 0.05)))
+                continue
+            
+            params = PHONEME_DATA[phoneme]
+            audio = self.synthesize_phoneme(params)
+            audio_segments.append(audio)
+        
+        if not audio_segments:
+            return np.zeros(self.sample_rate)
+        
+        audio = np.concatenate(audio_segments)
+        
+        if np.max(np.abs(audio)) > 0:
+            audio = audio / np.max(np.abs(audio)) * 0.8
+        
+        return audio
+    
+    def pitch_shift(self, audio, percent):
+        """
+        Pitch shift audio by a given percentage.
+        Positive percent = pitch up, Negative percent = pitch down.
+        
+        :param audio: input audio array
+        :param percent: percentage to shift
+        :return: pitch-shifted audio
+        """
+        if percent == 0.0:
+            return audio
+
+        ratio = 1.0 + (percent / 100.0)
+        
+        new_length = int(len(audio) / ratio)
+        return signal.resample(audio, new_length)
+    
+    def generate_silence(self, milliseconds):
+        duration_seconds = milliseconds / 1000.0
+        num_samples = int(self.sample_rate * duration_seconds)
+        return np.zeros(num_samples)
+    
+    def save_wav(self, audio, filename):
+        audio_int = np.int16(audio * 32767)
+        wavfile.write(filename, self.sample_rate, audio_int)
+        print(f"Saved to {filename}")
+
+    def play(self, audio, blocking=True):
+        from sounddevice import play, wait
+        
+        play(audio, self.sample_rate)
+        if blocking:
+            wait()
+
+
+if __name__ == "__main__":
+    synth = FormantSynthesizer()
+    
+    test_words = {
+        'this is dylans text to speech synthesizer': 'DH IH1 S IH1 Z D IH1 L AH0 N Z T EH1 K S T T UW1 S P IY1 CH S IH1 N TH AH0 S AY2 Z ER0'.split(),
+        'sahara please set me free': 'S AH0 HH EH1 R AH0 P L IY1 Z S EH1 T M IY1 F R IY1'.split(),
+        'its me five nights at freddys ar ar ar ar': 'IH1 T S M IY1 F AY1 V N AY1 T S AE1 T F R EH1 D IY0 Z AA1 R AA1 R AA1 R AA1 R'.split(),
+    }
+    
+    for word, phonemes in test_words.items():
+        print(f"Synthesizing: {word}")
+        audio = synth.synthesize(phonemes)
+        synth.save_wav(audio, f'test_word_files/{word}.wav')
+    
+    print("\nDone!")

barebones_tts/text_normalization.py

@@ -0,0 +1,284 @@
+import re
+from .tokenization import TokenList, Token
+# I moved these out here to keep from having to recompile all of the regexs everytime the replace_punctuation_and_expand_abreviations() runs
+
+COMMON_REPLACEMENT_RULES = [
+    # Titles
+    (re.compile(r'\bmr\.'), 'mister'),
+    (re.compile(r'\bmrs\.'), 'missus'),
+    (re.compile(r'\bms\.'), 'miss'),
+    (re.compile(r'\bdr\.'), 'doctor'),
+    (re.compile(r'\bprof\.'), 'professor'),
+    (re.compile(r'\brev\.'), 'reverend'),
+    (re.compile(r'\bgen\.'), 'general'),
+    (re.compile(r'\bsen\.'), 'senator'),
+    (re.compile(r'\brep\.'), 'representative'),
+    (re.compile(r'\bgov\.'), 'governor'),
+    (re.compile(r'\bcol\.'), 'colonel'),
+    (re.compile(r'\bcapt\.'), 'captain'),
+    
+    # Common abbreviations
+    (re.compile(r'\be\.g\.'), 'for example'),
+    (re.compile(r'\bi\.e\.'), 'that is'),
+    (re.compile(r'\betc\.'), 'et cetera'),
+    (re.compile(r'\bvs\.'), 'versus'),
+    (re.compile(r'\bvs\b'), 'versus'),
+    (re.compile(r'\bet al\.'), 'and others'),
+    (re.compile(r'\bapprox\.'), 'approximately'),
+    (re.compile(r'\bdept\.'), 'department'),
+    (re.compile(r'\bfig\.'), 'figure'),
+    (re.compile(r'\bno\.'), 'number'),
+    (re.compile(r'\bpg\.'), 'page'),
+    (re.compile(r'\bvol\.'), 'volume'),
+    (re.compile(r'\bch\.'), 'chapter'),
+    (re.compile(r'\bsec\.'), 'section'),
+    
+    # Time
+    (re.compile(r'\b(a\.m\.)'), ' a m '),
+    (re.compile(r'\b(p\.m\.)'), ' p m '),
+    
+    # Units (avoiding numbers)
+    (re.compile(r'(?<=\d)\s*ft\.'), ' feet '),
+    (re.compile(r'(?<=\d)\s*in\.'), ' inches '),
+    (re.compile(r'(?<=\d)\s*lb\.'), ' pounds '),
+    (re.compile(r'(?<=\d)\s*lbs\.'), ' pounds '),
+    (re.compile(r'(?<=\d)\s*oz\.'), ' ounces '),
+    
+    # Organizations
+    (re.compile(r'\bcorp\.'), 'corporation'),
+    (re.compile(r'\bco\.'), 'company'),
+    (re.compile(r'\binc\.'), 'incorporated'),
+    (re.compile(r'\bltd\.'), 'limited'),
+    (re.compile(r'\bl\.l\.c\.'), ' l l c '),
+    
+    # Directions
+    (re.compile(r'\bn\.'), 'north'),
+    (re.compile(r'\bs\.'), 'south'),
+    (re.compile(r'\be\.'), 'east'),
+    (re.compile(r'\bw\.'), 'west'),
+    (re.compile(r'\bne\b'), 'north east'),
+    (re.compile(r'\bnw\b'), 'north west'),
+    (re.compile(r'\bse\b'), 'south east'),
+    (re.compile(r'\bsw\b'), 'south west'),
+      
+]
+
+PUNCTUATION_REPLACEMENT_RULES = [
+    # These three have to run first to avoid some edge cases where they replace some of the tokens
+    (re.compile(r'\[',), ' open bracket '),
+    (re.compile(r'\]'), ' close bracket '),
+    (re.compile(r'(?<=\d),(?=\d)'), ''), # Remove commas in numbers
+
+    # Dollar sign 
+    (re.compile(r'\$(\d+(?:\.\d+)?)'), r'\1$'), # Swaps around the dollar sign to the end
+    (re.compile(r'(?<!\d)\$(?!\d)'), ' dollar sign '),
+
+    # Dots
+    (re.compile(r'\.\.\.'), ' dot dot dot '),
+    (re.compile(r'(?<=\d)\.(?=\d)'), ' point '),
+    (re.compile(r'(?<=\w)\.(?=\w)'), ' dot '),
+    
+    (re.compile(r'(\d+)\$'), r'\1 dollars '),
+
+    # Sentence endings
+    (re.compile(r'\.'), ' [PERIOD_SILENCE] '),
+    (re.compile(r'\?'), ' [QUESTION] '),
+    (re.compile(r'!'), ' [EXCLAMATION] '),
+    
+    # Pauses
+    (re.compile(r','), ' [COMMA_SILENCE] '),
+    (re.compile(r':'), ' colon '),
+    (re.compile(r';'), ' semi colon '),
+    
+    # Dashes and hyphens
+    (re.compile(r'—'), ' dash '),  # em dash
+    (re.compile(r'–'), ' dash '),  # en dash
+    (re.compile(r'--'), ' dash '),
+    (re.compile(r'(?<=\w)-(?=\w)'), ' '),  # hyphen between words (remove)
+    (re.compile(r'(?<=\s)-(?=\s)'), ' dash '),  # spaced dash
+    
+    # Parentheses and brackets
+    (re.compile(r'\('), ' open parenthesis '),
+    (re.compile(r'\)'), ' close parenthesis '),
+
+    
+    (re.compile(r'"'), ' [QUOTE] '),
+    
+    # Slashes
+    (re.compile(r'/'), ' slash '),
+    (re.compile(r'\\'), ' back slash '),
+    
+    # Ampersand
+    (re.compile(r'&'), ' and '),
+    
+    # At symbol
+    (re.compile(r'@'), ' at '),
+    
+    # Hashtag
+    (re.compile(r'#'), ' hashtag '),
+
+    # Percent sign
+    (re.compile(r'%'), ' percent '),
+    
+    # Asterisk
+    (re.compile(r'\*'), ' asterisk '),
+    (re.compile(r'\^'), ' caret '),
+]
+
+MULTIPLE_SPACES_PATTERN = re.compile(r'\s+')
+
+def numbers_to_words(number: int) -> list[str]:
+    """
+    Okay this is sorta shitass but it takes in an integer and returns the word version of that integer.
+    
+    :param int number: The number you want to turn into words
+    :return: The number specified in word form
+    :rtype: list[str]
+    
+    For example:
+
+    ```
+    numbers_to_words(1234567890)
+    ```
+
+    returns
+
+    ```
+    one billion two hundred thirty four million five hundred sixty seven thousand eight hundred ninety
+    ```
+
+
+    """
+    if number == 0:
+        return ["zero"]
+    
+    def three_digits(NUMBER):
+        ONES = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
+        TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
+
+        if NUMBER < 20:
+            return ONES[NUMBER]
+        elif NUMBER < 100:
+            return TENS[NUMBER // 10] + ( " " + ONES[NUMBER % 10] if NUMBER % 10 != 0 else "")
+        else:
+            return ONES[NUMBER // 100] + " hundred" + (" " + three_digits(NUMBER % 100) if NUMBER % 100 != 0 else "")
+
+    SCALES = ["", "thousand", "million", "billion", "trillion"]
+    words = []
+
+    for SCALE in SCALES:
+        if number % 1000 != 0:
+            words.append(three_digits(number % 1000) + (" " + SCALE if SCALE else ""))
+        number //= 1000
+        if number == 0:
+            break
+
+    return (" ".join(reversed(words)).strip()).split()
+
+
+def replace_punctuation_and_expand_abreviations(text: str) -> str:
+    """
+    Replaces punctuation and expands abreviations into full words in the given text. This is a preprocessing step for the text normalization step. Needs to be run **BEFORE** tokenization.
+    
+    :param text: Text you want to expand
+    :type text: str
+    :return: Expanded text
+    :rtype: str
+    """
+    text = str.lower(text)
+
+    # I separated out COMMON_REPLACEMENT_RULES and PUNCTUATION_REPLACEMENT_RULES to avoid edge cases like "Hello, Dr. Oz. How are you?" 
+    # being replaced with "hello [COMMA_SILENCE] dr [PERIOD_SILENCE] oz [PERIOD_SILENCE] how are you?" 
+    # instead of the correct "hello [COMMA_SILENCE] doctor oz [PERIOD_SILENCE] how are you?"
+
+    for pattern, replacement in COMMON_REPLACEMENT_RULES:
+        text = pattern.sub(replacement, text)
+
+    for pattern, replacement in PUNCTUATION_REPLACEMENT_RULES:
+        text = pattern.sub(replacement, text)
+
+    #text = re.sub(MULTIPLE_SPACES_PATTERN, ' ', text).strip()
+    text = MULTIPLE_SPACES_PATTERN.sub(' ', text).strip()
+
+    return text
+
+def set_modifiers_from_table(tokens: TokenList) -> TokenList:
+    MODIFIER_TABLE = { # MODIFIER_NAME: [SILENCE_TIME (ms), PITCH_MODIFIER (%), MODIFIES_PREVIOUS_TOKEN]
+        '[PERIOD_SILENCE]': [300.0, 0.0, False],
+        '[COMMA_SILENCE]': [190.0, 0.0, False],
+        '[QUESTION]': [280.0, 20.0, True],
+        '[EXCLAMATION]': [280.0, 5.0, True],
+        '[QUOTE]': [0.0, 0.0, False], # All quotes will be removed and replaced with proper words during normalization
+    }
+
+    for token in tokens:
+        text = token.get_text()
+
+        if text in MODIFIER_TABLE:
+            token.set_modifier_flag(True)
+            token.set_silence_time(MODIFIER_TABLE[text][0])
+            token.set_pitch_modifier(MODIFIER_TABLE[text][1])
+            token.set_modifies_previous_token_flag(MODIFIER_TABLE[text][2])
+        else:
+            token.set_speakable_flag(True)
+
+    return tokens
+
+
+
+def normalize_text(text: str) -> TokenList:
+    """
+    Takes text and transforms it into a more speakable version of it (in token form)
+
+    ## Example
+
+    ```python
+    normalize_text('she said, "Hello World" and that I owe her $123.')
+    ```
+
+    Returns a tokenized list that looks like this:
+
+    ```python
+    [{'text': 'she'}, {'text': 'said'}, {'text': '[COMMA_SILENCE]', 'modifies_previous_token': False, 'silence_time': 190.0, 'pitch_modifier': 0.0}, {'text': 'quote'}, {'text': 'hello'}, {'text': 'world'}, {'text': 'unquote'}, {'text': 'and'}, {'text': 'that'}, {'text': 'i'}, {'text': 'owe'}, {'text': 'her'}, {'text': 'one'}, {'text': 'hundred'}, {'text': 'twenty'}, {'text': 'three'}, {'text': 'dollars'}, {'text': '[PERIOD_SILENCE]', 'modifies_previous_token': False, 'silence_time': 300.0, 'pitch_modifier': 0.0}]
+    ```
+    
+    :param text: Text to normalize
+    :type text: str
+    :return: Normalized text
+    :rtype: TokenList
+    """
+
+    text = replace_punctuation_and_expand_abreviations(text)
+    tokens = TokenList(text)
+
+    expanded_tokens = []
+    quote_opened = False
+
+    for token in tokens:
+        if token.get_text().isdigit():
+            token_converted_to_words = numbers_to_words(int(token.get_text()))
+            for word in token_converted_to_words:
+                expanded_tokens.append(Token(TEXT=word))
+        elif token.get_text() == '[QUOTE]':
+            if not quote_opened:
+                expanded_tokens.append(Token(TEXT='quote'))
+            else:
+                expanded_tokens.append(Token(TEXT='unquote'))
+
+            quote_opened = not quote_opened
+        else:
+            expanded_tokens.append(token)
+
+    tokens.set_list(expanded_tokens)
+
+    tokens = set_modifiers_from_table(tokens)
+
+    return tokens
+
+def main():
+    normalized_text = normalize_text('she said, "Hello World" and that I owe her $123.')
+    print(normalized_text)
+
+
+if __name__ == '__main__':
+    main()

barebones_tts/tokenization.py

@@ -0,0 +1,130 @@
+class Token:
+    def __init__(self, TEXT: str = "", IS_MODIFIER: bool = False, MODIFIES_PREVIOUS_TOKEN: bool = False, IS_SPEAKABLE: bool = False, SILENCE_TIME: float = 0.0, PITCH_MODIFIER: float = 0.0):
+        self._text: str = TEXT.strip()
+        self._phoneme : list[str] = []
+        self._is_modifier: bool = IS_MODIFIER
+        self._is_speakable: bool = IS_SPEAKABLE
+
+        if self._is_modifier:
+            self._modifies_previous_token: bool = MODIFIES_PREVIOUS_TOKEN
+            self._silence_time: float = SILENCE_TIME
+            self._pitch_modifier: float = PITCH_MODIFIER
+        pass
+
+    def set_text(self, TEXT: str):
+        self._text = TEXT
+        
+    def get_text(self) -> str:
+        return self._text
+
+    def set_phoneme(self, PHONEME: list[str]):
+        self._phoneme = PHONEME
+
+    def get_phoneme(self) -> list[str]:
+        return self._phoneme
+
+    def set_modifier_flag(self, IS_MODIFIER: bool):
+        self._is_modifier = IS_MODIFIER
+
+    def get_modifier_flag(self) -> bool:
+        return self._is_modifier
+
+    def set_modifies_previous_token_flag(self, MODIFIES_PREVIOUS_TOKEN: bool):
+        self._modifies_previous_token = MODIFIES_PREVIOUS_TOKEN
+
+    def get_modifies_previous_token_flag(self) -> bool:
+        return self._modifies_previous_token
+    
+    def set_silence_time(self, SILENCE_TIME: float):
+            self._silence_time = SILENCE_TIME
+
+    def get_silence_time(self) -> float:
+        return self._silence_time
+
+    def set_pitch_modifier(self, PITCH_MODIFIER: float):
+            self._pitch_modifier = PITCH_MODIFIER
+
+    def get_pitch_modifier(self) -> float:
+        return self._pitch_modifier
+    
+    def set_speakable_flag(self, IS_SPEAKABLE: bool):
+        self._is_speakable = IS_SPEAKABLE
+
+    def get_speakable_flag(self) -> bool:
+        return self._is_speakable
+
+    
+class TokenList:
+    def __init__(self, input_data=None):
+
+        if input_data is None:
+            self._tokens: list[Token] = []
+        elif isinstance(input_data, str): # check if it's a string
+            self._tokens: list[Token] = self.list_to_tokens(input_data.split())
+        elif isinstance(input_data, list): # check if it's a list of tokens
+            if all(isinstance(item, Token) for item in input_data):
+                self._tokens: list[Token] = input_data
+            else: #it's probably a list of strings if it's not a list of tokens
+                self._tokens: list[Token] = self.list_to_tokens(input_data) 
+        else:
+            raise TypeError("TokenList requires a string, list of strings, or list of Tokens")
+
+    def __iter__(self):
+        return iter(self._tokens)
+
+    def list_to_tokens(self, LIST_OF_RAW_TEXT: list[str]) -> list[Token]:
+        output_list: list[Token] = []
+
+        for text in LIST_OF_RAW_TEXT:
+            text_token = Token(TEXT=text)
+            output_list.append(text_token)
+
+        return output_list
+    
+    def to_dict_list(self):
+        output_list = []
+
+        for token in self._tokens:
+            if token._is_modifier:
+                output_list.append({'text': token._text, 'modifies_previous_token': token._modifies_previous_token, 'is_speakable': token._is_speakable, 'silence_time': token._silence_time, 'pitch_modifier': token._pitch_modifier})
+            else:
+                output_list.append({'text': token._text, 'phoneme': token._phoneme})
+        return output_list
+    
+    def to_json(self):
+        return self.to_dict_list()
+
+    def __str__(self):
+        return str(self.to_dict_list())
+    
+    def get(self, index: int) -> Token:
+        TOKEN_LIST_SIZE: int = len(self._tokens)
+        if index > TOKEN_LIST_SIZE or index < 0:
+            raise IndexError(f"Attempted to access out of bounds token {index}")
+
+        return self._tokens[index]
+    
+    def set(self, index: int, token: Token):
+        TOKEN_LIST_SIZE: int = len(self._tokens)
+        if index > TOKEN_LIST_SIZE + 1 or index < 0: # add one to token list size because in that case, it will just be appended at the end of the list
+            raise IndexError(f"Attempted to access out of bounds token {index}")
+        
+        if index == TOKEN_LIST_SIZE + 1:
+            self.append(token)
+        else:
+            self._tokens[index] = token
+
+    def set_list(self, token_list: list[Token]):
+        self._tokens = token_list
+
+    def append(self, token: Token):
+        self._tokens.append(token)
+
+def main():
+    token = Token("Hello")
+    tokens = TokenList(["hello", "world"])
+
+    print(token)
+    print(tokens)
+if __name__ == "__main__":
+    main()

barebones_tts-0.1.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.5
+Name: barebones-tts
+Version: 0.1.0
+Summary: I wanted a TTS from first principles
+Project-URL: Homepage, https://tts.dylanoonk.net
+Project-URL: Repository, https://github.com/dylanoonk/barebones-tts
+Author: Dylan Oonk
+License-Expression: MIT
+License-File: LICENSE
+Keywords: arpabet,audio,formant-synthesis,speech-synthesis,text-to-speech,tts
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.13
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: numpy>=2.5.3
+Requires-Dist: scipy>=1.18.1
+Requires-Dist: sounddevice>=0.5.6
+Description-Content-Type: text/markdown
+
+# Barebones Text To Speech
+
+I wrote a text-to-speech system from first principles because I wanted to learn how old-timey text-to-speech systems worked. I'll make a video or something on how it works because there weren't any good in-depth videos about non-nueral-network text-to-speech systems.
+
+## How to install
+
+Use `pip` to install
+
+```bash
+pip install barebones-tts
+```
+
+## Start speaking
+
+Literally just
+
+```bash
+python3 barebones-tts.py
+```
+
+...and start typing. This is still in early development so this will change soon to be better.
+
+If you want to save the audio to a wav file then use the `--wav` or `-w` flags.
+
+```bash
+python3 barebones-tts.py --wav
+```
+
+Also, to use, just import like normal and start speaking:
+
+```python
+from barebones-tts import barebones_tts
+
+barebones = barebones_tts()
+barebones.speak("Hello world.")
+```

barebones_tts-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+barebones_tts/__init__.py,sha256=7VRnQ0g8erNbJ1LGrCcPLZGGk3p4q6AL6_DE0TRAyzE,83
+barebones_tts/__main__.py,sha256=eJMDMFdKPZmRiXXRxsJyiKiU7dajxUpGR7wvT-nB7s0,1030
+barebones_tts/arpabet.py,sha256=VZ1BB1rioancu8E0i6beQ99_c4PcRhM5pe4rWCxcT1M,2258
+barebones_tts/core.py,sha256=BWfYDIeL4Y2wAs4sKy3qp1W7GZt8EXgmhTSZMpFHBWQ,3038
+barebones_tts/formant_synth.py,sha256=_aYjRoVzM1SZPmzWUGYXv21MSMg_dCynNhAfhzaL7Kg,12776
+barebones_tts/text_normalization.py,sha256=nkHn8UQZkLcQuEkapGr7VrypTlGCIlhdCzOqVnShILI,9689
+barebones_tts/tokenization.py,sha256=i2RN0uk2ayF3ljdnr6vyB99jUF5tlTV0H-jz7FaUjsk,4573
+barebones_tts/data/pronunciation.pkl,sha256=-yS2M4z3Ywb3GKytZDIWR--qUaytnY7q_3syJNR119Y,3835147
+barebones_tts-0.1.0.dist-info/METADATA,sha256=k5hxaQvt5Z0OxxktgtMzXqpY8Pio-rNYex8eAp5pEuc,1692
+barebones_tts-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+barebones_tts-0.1.0.dist-info/entry_points.txt,sha256=yxDmzG1tTgTX1xtffGIjKFviGJQqpbaV3CyBMd0psH4,62
+barebones_tts-0.1.0.dist-info/licenses/LICENSE,sha256=ZNgmQHhfQREuX292wYq3U9Bt6wRlk3mJFOEvr1MoMVQ,1067
+barebones_tts-0.1.0.dist-info/RECORD,,

barebones_tts-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

barebones_tts-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+barebones-tts = barebones_tts.__main__:main

barebones_tts-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dylan Oonk
+
+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.