reaowl 0.0.3__py3-none-any.whl

reaowl/__init__.py

@@ -0,0 +1,1937 @@
+from kokoro import KPipeline
+
+from IPython.display import Audio, display, HTML
+
+import soundfile as sf
+import numpy as np
+
+import re
+import os
+import json
+import html
+import base64
+
+
+class T2S:
+
+    # =========================================================
+    # INITIALIZE
+    # =========================================================
+
+    def __init__(
+        self,
+        text='',
+        filename='',
+        speed=1.0,
+        voice="af_nicole",
+        lang_code="a"
+    ):
+
+          
+
+        if text == '':
+         self.original_text = self.extract_text(filepath=filename)
+        else: 
+         self.original_text = text
+
+
+
+        self.speed = speed
+        self.voice = voice
+        self.lang_code = lang_code
+
+        # Create Kokoro pipeline
+        self.pipeline = KPipeline(
+            lang_code=self.lang_code
+        )
+
+        # Clean and align text
+        self.text = self.align()
+
+        # Sentence structure used by BOTH readers
+        self.sentences = self.make_sentences()
+
+        self.file = None
+        self.timings_file = None
+        self.word_timings = []
+
+
+    # =========================================================
+    # ALIGN TEXT
+    # =========================================================
+
+    def align(self):
+
+        text = self.original_text
+
+        # Windows / Linux line endings
+        text = text.replace("\r\n", "\n")
+        text = text.replace("\r", "\n")
+
+        # Join words broken by PDF hyphenation
+        text = re.sub(
+            r"(\w+)-\s*\n\s*(\w+)",
+            r"\1\2",
+            text
+        )
+
+        # Separate paragraphs
+        paragraphs = re.split(
+            r"\n\s*\n+",
+            text
+        )
+
+        cleaned_paragraphs = []
+
+        for paragraph in paragraphs:
+
+            # Convert line breaks inside paragraph to spaces
+            paragraph = re.sub(
+                r"\s*\n\s*",
+                " ",
+                paragraph
+            )
+
+            # Remove repeated spaces
+            paragraph = re.sub(
+                r"[ \t]+",
+                " ",
+                paragraph
+            )
+
+            paragraph = paragraph.strip()
+
+            if paragraph:
+                cleaned_paragraphs.append(
+                    paragraph
+                )
+
+        # Split sentences
+        output_parts = []
+
+        for paragraph in cleaned_paragraphs:
+
+            sentences = re.split(
+                r"(?<=[.!?])\s+",
+                paragraph
+            )
+
+            sentences = [
+                sentence.strip()
+                for sentence in sentences
+                if sentence.strip()
+            ]
+
+            output_parts.append(
+                "\n".join(sentences)
+            )
+
+        output_text = "\n\n".join(
+            output_parts
+        )
+
+        print("\n==============================")
+        print("ALIGNED TEXT")
+        print("==============================\n")
+        print(output_text)
+
+        return output_text
+
+
+    # =========================================================
+    # MAKE SENTENCES
+    # =========================================================
+
+    def make_sentences(self):
+
+        paragraphs = self.text.split("\n\n")
+
+        sentences = []
+
+        for paragraph in paragraphs:
+
+            lines = paragraph.split("\n")
+
+            for line in lines:
+
+                line = line.strip()
+
+                if not line:
+                    continue
+
+                # Make actual words
+                words = re.findall(
+                    r"\S+",
+                    line
+                )
+
+                sentences.append({
+                    "text": line,
+                    "words": words
+                })
+
+        return sentences
+
+
+    # =========================================================
+    # EXTRACT TOKEN TEXT
+    # =========================================================
+
+    def _token_text(self, token):
+
+        # Dictionary
+        if isinstance(token, dict):
+
+            for key in [
+                "text",
+                "token",
+                "word"
+            ]:
+
+                if key in token:
+                    return str(
+                        token[key]
+                    )
+
+        # Object
+        for attr in [
+            "text",
+            "token",
+            "word"
+        ]:
+
+            if hasattr(token, attr):
+
+                value = getattr(
+                    token,
+                    attr
+                )
+
+                if value is not None:
+                    return str(value)
+
+        # Fallback
+        return str(token)
+
+
+    # =========================================================
+    # EXTRACT TOKEN START
+    # =========================================================
+
+    def _token_start(self, token):
+
+        if isinstance(token, dict):
+
+            for key in [
+                "start",
+                "start_ts",
+                "start_time"
+            ]:
+
+                if key in token:
+                    return float(
+                        token[key]
+                    )
+
+        for attr in [
+            "start",
+            "start_ts",
+            "start_time"
+        ]:
+
+            if hasattr(token, attr):
+
+                value = getattr(
+                    token,
+                    attr
+                )
+
+                if value is not None:
+                    return float(value)
+
+        return None
+
+
+    # =========================================================
+    # EXTRACT TOKEN END
+    # =========================================================
+
+    def _token_end(self, token):
+
+        if isinstance(token, dict):
+
+            for key in [
+                "end",
+                "end_ts",
+                "end_time"
+            ]:
+
+                if key in token:
+                    return float(
+                        token[key]
+                    )
+
+        for attr in [
+            "end",
+            "end_ts",
+            "end_time"
+        ]:
+
+            if hasattr(token, attr):
+
+                value = getattr(
+                    token,
+                    attr
+                )
+
+                if value is not None:
+                    return float(value)
+
+        return None
+
+
+    # =========================================================
+    # NORMALIZE TOKEN
+    # =========================================================
+
+    def _normalize(self, text):
+
+        return re.sub(
+            r"[^A-Za-z0-9']+",
+            "",
+            text
+        ).lower()
+
+
+    # =========================================================
+    # CREATE WORD TIMINGS
+    #
+    # Important:
+    #
+    # Kokoro can return token-level timing.
+    # We convert those timings into the ACTUAL
+    # words displayed by the Focus Reader.
+    # =========================================================
+
+    def _build_word_timings(
+        self,
+        tokens,
+        chunk_offset
+    ):
+
+        token_data = []
+
+        for token in tokens:
+
+            text = self._token_text(
+                token
+            )
+
+            start = self._token_start(
+                token
+            )
+
+            end = self._token_end(
+                token
+            )
+
+            if start is None or end is None:
+                continue
+
+            token_data.append({
+                "text": text,
+                "start": float(start) + chunk_offset,
+                "end": float(end) + chunk_offset
+            })
+
+        return token_data
+
+
+    # =========================================================
+    # MAP TOKENS -> ACTUAL WORDS
+    # =========================================================
+
+    def _tokens_to_words(
+        self,
+        token_data,
+        words
+    ):
+
+        result = []
+
+        token_index = 0
+
+        for word in words:
+
+            target = self._normalize(
+                word
+            )
+
+            # Empty / punctuation-only word
+            if not target:
+
+                result.append({
+                    "text": word,
+                    "start": None,
+                    "end": None
+                })
+
+                continue
+
+            collected = ""
+
+            word_start = None
+            word_end = None
+
+            start_token_index = token_index
+
+            while token_index < len(token_data):
+
+                token = token_data[
+                    token_index
+                ]
+
+                token_text = self._normalize(
+                    token["text"]
+                )
+
+                # Ignore pure punctuation
+                if not token_text:
+
+                    token_index += 1
+                    continue
+
+                if word_start is None:
+
+                    word_start = token[
+                        "start"
+                    ]
+
+                word_end = token[
+                    "end"
+                ]
+
+                collected += token_text
+
+                token_index += 1
+
+                # We have consumed this word
+                if (
+                    collected == target
+                    or collected.startswith(target)
+                    or target.startswith(collected)
+                ):
+
+                    if collected == target:
+
+                        break
+
+                    if collected.startswith(target):
+
+                        break
+
+            # If matching failed, try to use
+            # the first available token.
+            if word_start is None:
+
+                if start_token_index < len(
+                    token_data
+                ):
+
+                    word_start = token_data[
+                        start_token_index
+                    ]["start"]
+
+                    word_end = token_data[
+                        start_token_index
+                    ]["end"]
+
+            result.append({
+                "text": word,
+                "start": word_start,
+                "end": word_end
+            })
+
+        return result
+
+
+    # =========================================================
+    # FIX MISSING TIMINGS
+    #
+    # If a punctuation / token mismatch occurs,
+    # interpolate missing word timing rather than
+    # deleting the word.
+    # =========================================================
+
+    def _fix_missing_timings(
+        self,
+        word_timings,
+        total_duration
+    ):
+
+        if not word_timings:
+            return word_timings
+
+        # First known timing
+        known = [
+            i
+            for i, item in enumerate(
+                word_timings
+            )
+            if item["start"] is not None
+        ]
+
+        if not known:
+            return word_timings
+
+        # Missing values before first known word
+        first = known[0]
+
+        if first > 0:
+
+            next_start = word_timings[
+                first
+            ]["start"]
+
+            step = next_start / (
+                first + 1
+            )
+
+            for i in range(first):
+
+                word_timings[i]["start"] = (
+                    i * step
+                )
+
+                word_timings[i]["end"] = (
+                    (i + 1) * step
+                )
+
+        # Missing values between known words
+        i = 0
+
+        while i < len(word_timings):
+
+            if word_timings[i]["start"] is not None:
+
+                i += 1
+                continue
+
+            start_missing = i
+
+            while (
+                i < len(word_timings)
+                and
+                word_timings[i]["start"] is None
+            ):
+
+                i += 1
+
+            end_missing = i - 1
+
+            previous = start_missing - 1
+            following = i
+
+            if (
+                previous >= 0
+                and following < len(word_timings)
+                and word_timings[previous]["end"] is not None
+                and word_timings[following]["start"] is not None
+            ):
+
+                a = word_timings[
+                    previous
+                ]["end"]
+
+                b = word_timings[
+                    following
+                ]["start"]
+
+                count = (
+                    end_missing
+                    - start_missing
+                    + 2
+                )
+
+                step = (
+                    b - a
+                ) / count
+
+                for j in range(
+                    start_missing,
+                    end_missing + 1
+                ):
+
+                    k = (
+                        j
+                        - start_missing
+                        + 1
+                    )
+
+                    word_timings[j][
+                        "start"
+                    ] = a + step * (k - 1)
+
+                    word_timings[j][
+                        "end"
+                    ] = a + step * k
+
+        # Missing values at end
+        last_known = None
+
+        for i in range(
+            len(word_timings)
+        ):
+
+            if word_timings[i][
+                "start"
+            ] is not None:
+
+                last_known = i
+
+        if (
+            last_known is not None
+            and last_known < len(
+                word_timings
+            ) - 1
+        ):
+
+            start = word_timings[
+                last_known
+            ]["end"]
+
+            remaining = (
+                len(word_timings)
+                - last_known
+                - 1
+            )
+
+            duration = max(
+                0.05,
+                (
+                    total_duration
+                    - start
+                ) / (remaining + 1)
+            )
+
+            for j in range(
+                last_known + 1,
+                len(word_timings)
+            ):
+
+                word_timings[j][
+                    "start"
+                ] = (
+                    start
+                    + duration
+                    * (
+                        j
+                        - last_known
+                        - 1
+                    )
+                )
+
+                word_timings[j][
+                    "end"
+                ] = (
+                    start
+                    + duration
+                    * (
+                        j
+                        - last_known
+                    )
+                )
+
+        # Final safety clamp
+        for item in word_timings:
+
+            if item["start"] is None:
+                item["start"] = 0.0
+
+            if item["end"] is None:
+                item["end"] = (
+                    item["start"]
+                    + 0.05
+                )
+
+            if item["end"] < item["start"]:
+
+                item["end"] = (
+                    item["start"]
+                    + 0.05
+                )
+
+        return word_timings
+
+
+    # =========================================================
+    # GENERATE AUDIO + TIMINGS
+    # =========================================================
+
+    def generate(
+        self,
+        file="test.wav",
+        force=False
+    ):
+
+        print("Test tube ")
+        self.file = file
+
+        self.timings_file = (file+ "_timings.json")
+
+
+        print(f"Test tube = {self.file}, {self.timings_file}")
+
+
+        # =====================================================
+        # CACHE
+        # =====================================================
+
+        if (
+            not force
+            and os.path.exists(file)
+            and os.path.exists(
+                self.timings_file
+            )
+        ):
+
+            print(
+                "Using cached audio and timings."
+            )
+
+            with open(
+                self.timings_file,
+                "r",
+                encoding="utf-8"
+            ) as f:
+
+                self.word_timings = json.load(
+                    f
+                )
+
+            return
+
+
+        print(
+            "Generating Kokoro audio..."
+        )
+
+        audio_parts = []
+
+        all_token_data = []
+
+        chunk_offset = 0.0
+
+        # =====================================================
+        # GENERATOR
+        # =====================================================
+
+        generator = self.pipeline(
+            self.text,
+            voice=self.voice,
+            speed=self.speed
+        )
+
+        for result in generator:
+
+            if result.audio is not None:
+
+                audio = (
+                    result.audio
+                    .detach()
+                    .cpu()
+                    .numpy()
+                )
+
+                audio_parts.append(
+                    audio
+                )
+
+                chunk_duration = (
+                    len(audio)
+                    / 24000.0
+                )
+
+                # =================================================
+                # TOKEN TIMINGS
+                # =================================================
+
+                if hasattr(
+                    result,
+                    "tokens"
+                ):
+
+                    tokens = result.tokens
+
+                    token_data = (
+                        self._build_word_timings(
+                            tokens,
+                            chunk_offset
+                        )
+                    )
+
+                    all_token_data.extend(
+                        token_data
+                    )
+
+                chunk_offset += (
+                    chunk_duration
+                )
+
+        if not audio_parts:
+
+            raise RuntimeError(
+                "Kokoro did not generate audio."
+            )
+
+        # =====================================================
+        # JOIN AUDIO
+        # =====================================================
+
+        audio = np.concatenate(
+            audio_parts
+        )
+
+        sf.write(
+            file,
+            audio,
+            24000
+        )
+
+        total_duration = (
+            len(audio)
+            / 24000.0
+        )
+
+        # =====================================================
+        # MAP TOKEN TIMINGS TO REAL WORDS
+        # =====================================================
+
+        all_words = []
+
+        for sentence in self.sentences:
+
+            all_words.extend(
+                sentence["words"]
+            )
+
+        self.word_timings = (
+            self._tokens_to_words(
+                all_token_data,
+                all_words
+            )
+        )
+
+        # =====================================================
+        # FIX ANY MISSING TIMINGS
+        # =====================================================
+
+        self.word_timings = (
+            self._fix_missing_timings(
+                self.word_timings,
+                total_duration
+            )
+        )
+
+        # =====================================================
+        # SAVE TIMINGS
+        # =====================================================
+
+        with open(
+            self.timings_file,
+            "w",
+            encoding="utf-8"
+        ) as f:
+
+            json.dump(
+                self.word_timings,
+                f,
+                ensure_ascii=False,
+                indent=2
+            )
+
+        print()
+        print(
+            "Audio saved:",
+            file
+        )
+
+        print(
+            "Timings saved:",
+            self.timings_file
+        )
+
+        print(
+            "Duration:",
+            round(
+                total_duration,
+                2
+            ),
+            "seconds"
+        )
+
+
+    # =========================================================
+    # DISPLAY AUDIO
+    # =========================================================
+
+    def display(
+        self,
+        autoplay=True
+    ):
+
+        if self.file is None:
+
+            raise RuntimeError(
+                "Run generate() first."
+            )
+
+        display(
+            Audio(
+                self.file,
+                autoplay=autoplay
+            )
+        )
+
+
+    # =========================================================
+    # DISPLAY ANOTHER AUDIO FILE
+    # =========================================================
+
+    def display_audio(
+        self,
+        file,
+        autoplay=True
+    ):
+
+        display(
+            Audio(
+                file,
+                autoplay=autoplay
+            )
+        )
+
+
+    # =========================================================
+    # CREATE ALIGNED READER HTML
+    # =========================================================
+
+    def _aligned_reader_html(self):
+
+        output = ""
+
+        for sentence in self.sentences:
+
+            output += (
+                '<div class="t2s-aligned-sentence">'
+            )
+
+            output += html.escape(
+                sentence["text"]
+            )
+
+            output += "</div>"
+
+        return output
+
+
+    # =========================================================
+    # CREATE FOCUS READER HTML
+    # =========================================================
+
+    def _focus_reader_html(self):
+
+        output = ""
+
+        global_index = 0
+
+        timing_index = 0
+
+        for sentence in self.sentences:
+
+            output += (
+                '<div class="t2s-focus-sentence">'
+            )
+
+            for word in sentence["words"]:
+
+                if (
+                    timing_index
+                    < len(self.word_timings)
+                ):
+
+                    timing = (
+                        self.word_timings[
+                            timing_index
+                        ]
+                    )
+
+                else:
+
+                    timing = {
+                        "start": 0.0,
+                        "end": 0.05
+                    }
+
+                start = float(
+                    timing["start"]
+                )
+
+                end = float(
+                    timing["end"]
+                )
+
+                output += f'''
+<span
+    class="t2s-word"
+    data-index="{global_index}"
+    data-start="{start:.4f}"
+    data-end="{end:.4f}"
+>{html.escape(word)}</span> '''
+
+                global_index += 1
+                timing_index += 1
+
+            output += "</div>"
+
+        return output
+
+
+
+    def extract_text(self,filepath):
+            try:
+                with open(filepath, 'r') as file:
+                    content = file.read()
+                return content
+            except FileNotFoundError:
+                print(f"File not found: {filepath}")
+                return None
+
+    # =========================================================
+    # READER
+    # =========================================================
+
+    def reader(self):
+
+        if self.file is None:
+
+            raise RuntimeError(
+                "Run generate() first."
+            )
+
+        if not os.path.exists(
+            self.file
+        ):
+
+            raise FileNotFoundError(
+                self.file
+            )
+
+        # =====================================================
+        # READ AUDIO
+        # =====================================================
+
+        with open(
+            self.file,
+            "rb"
+        ) as f:
+
+            audio_bytes = f.read()
+
+        audio_base64 = base64.b64encode(
+            audio_bytes
+        ).decode("utf-8")
+
+        # =====================================================
+        # HTML
+        # =====================================================
+
+        aligned_html = (
+            self._aligned_reader_html()
+        )
+
+        focus_html = (
+            self._focus_reader_html()
+        )
+
+        page = f"""
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="UTF-8">
+
+<style>
+
+/* =========================================================
+   MAIN
+   ========================================================= */
+
+.t2s-container {{
+    width: 100%;
+    max-width: 1100px;
+
+    margin: 20px auto;
+
+    font-family:
+        Arial,
+        Helvetica,
+        sans-serif;
+
+    color: #111111;
+}}
+
+
+/* =========================================================
+   TITLE
+   ========================================================= */
+
+.t2s-title {{
+    font-size: 26px;
+    font-weight: bold;
+
+    margin-top: 25px;
+    margin-bottom: 12px;
+
+    color: #111111;
+}}
+
+
+/* =========================================================
+   ALIGNED READER
+   ========================================================= */
+
+.t2s-aligned-reader {{
+
+    width: 100%;
+
+    box-sizing: border-box;
+
+    padding: 22px;
+
+    background: #ffffff;
+
+    border: 1px solid #dddddd;
+
+    border-radius: 10px;
+
+    color: #111111;
+
+    font-size: 22px;
+
+    line-height: 1.8;
+
+    text-align: left;
+}}
+
+
+.t2s-aligned-sentence {{
+
+    display: block;
+
+    margin-bottom: 16px;
+
+    color: #111111;
+
+    text-align: left;
+
+    white-space: normal;
+
+    overflow-wrap: break-word;
+}}
+
+
+/* =========================================================
+   FOCUS READER
+   ========================================================= */
+
+.t2s-focus-reader {{
+
+    width: 100%;
+
+    box-sizing: border-box;
+
+    padding: 22px;
+
+    background: #ffffff;
+
+    border: 1px solid #dddddd;
+
+    border-radius: 10px;
+
+    color: #111111;
+
+    font-size: 28px;
+
+    line-height: 2.0;
+
+    text-align: left;
+}}
+
+
+/* =========================================================
+   EACH SENTENCE IS ONE BLOCK
+   ========================================================= */
+
+.t2s-focus-sentence {{
+
+    display: block;
+
+    width: 100%;
+
+    margin-bottom: 20px;
+
+    padding: 5px 8px;
+
+    box-sizing: border-box;
+
+    color: #111111;
+
+    text-align: left;
+
+    white-space: normal;
+
+    overflow-wrap: break-word;
+}}
+
+
+/* =========================================================
+   WORD
+   ========================================================= */
+
+.t2s-word {{
+
+    display: inline;
+
+    color: #111111;
+
+    background: transparent;
+
+    cursor: pointer;
+
+    border-radius: 5px;
+
+    padding: 2px 4px;
+
+    margin: 0;
+
+    transition:
+        background 0.08s,
+        color 0.08s;
+}}
+
+
+/* =========================================================
+   CURRENT SPOKEN WORD
+   ========================================================= */
+
+.t2s-word.active {{
+
+    background: yellow;
+
+    color: #000000;
+
+}}
+
+
+/* =========================================================
+   AUDIO
+   ========================================================= */
+
+.t2s-audio {{
+
+    width: 100%;
+
+    margin-top: 15px;
+
+}}
+
+
+/* =========================================================
+   CONTROLS
+   ========================================================= */
+
+.t2s-controls {{
+
+    display: flex;
+
+    flex-wrap: wrap;
+
+    gap: 8px;
+
+    margin-top: 15px;
+
+    margin-bottom: 15px;
+}}
+
+
+.t2s-controls button,
+.t2s-controls select {{
+
+    font-size: 16px;
+
+    padding: 8px 14px;
+
+    border: 1px solid #cccccc;
+
+    border-radius: 6px;
+
+    background: #ffffff;
+
+    color: #111111;
+
+    cursor: pointer;
+}}
+
+
+.t2s-controls button:hover {{
+
+    background: #eeeeee;
+}}
+
+
+</style>
+
+</head>
+
+
+<body>
+
+<div class="t2s-container">
+
+
+<div class="t2s-title">
+Aligned Reader
+</div>
+
+
+<div class="t2s-aligned-reader">
+
+{aligned_html}
+
+</div>
+
+
+<div class="t2s-title">
+Focus Reader
+</div>
+
+
+<div class="t2s-focus-reader"
+     id="t2sFocusReader">
+
+{focus_html}
+
+</div>
+
+
+<audio
+    id="t2sAudio"
+    class="t2s-audio"
+    controls>
+
+<source
+    src="data:audio/wav;base64,{audio_base64}"
+    type="audio/wav">
+
+</audio>
+
+
+<div class="t2s-controls">
+
+<button id="t2sPrevious">
+Previous
+</button>
+
+<button id="t2sNext">
+Next
+</button>
+
+<button id="t2sRepeat">
+Repeat Word
+</button>
+
+<button id="t2sPlayPause">
+Play / Pause
+</button>
+
+<select id="t2sSpeed">
+
+<option value="0.75">
+0.75x
+</option>
+
+<option value="0.9" selected>
+0.9x
+</option>
+
+<option value="1.0">
+1.0x
+</option>
+
+<option value="1.1">
+1.1x
+</option>
+
+<option value="1.25">
+1.25x
+</option>
+
+<option value="1.5">
+1.5x
+</option>
+
+</select>
+
+</div>
+
+
+</div>
+
+
+<script>
+
+
+// =========================================================
+// AUDIO
+// =========================================================
+
+const t2sAudio =
+    document.getElementById(
+        "t2sAudio"
+    );
+
+
+// =========================================================
+// WORDS
+// =========================================================
+
+const t2sWords =
+    Array.from(
+        document.querySelectorAll(
+            ".t2s-word"
+        )
+    );
+
+
+// =========================================================
+// CURRENT WORD
+// =========================================================
+
+let t2sCurrentWord = -1;
+
+
+// =========================================================
+// REMOVE HIGHLIGHT
+// =========================================================
+
+function t2sRemoveHighlight() {{
+
+    if (
+        t2sCurrentWord >= 0 &&
+        t2sCurrentWord <
+            t2sWords.length
+    ) {{
+
+        t2sWords[
+            t2sCurrentWord
+        ].classList.remove(
+            "active"
+        );
+
+    }}
+
+}}
+
+
+// =========================================================
+// SET HIGHLIGHT
+// =========================================================
+
+function t2sSetWord(index) {{
+
+    if (
+        index < 0 ||
+        index >= t2sWords.length
+    ) {{
+        return;
+    }}
+
+    t2sRemoveHighlight();
+
+    t2sCurrentWord = index;
+
+    t2sWords[
+        index
+    ].classList.add(
+        "active"
+    );
+
+    // Keep current word visible
+    t2sWords[
+        index
+    ].scrollIntoView({{
+        behavior: "smooth",
+        block: "center"
+    }});
+
+}}
+
+
+// =========================================================
+// FIND WORD FROM AUDIO TIME
+// =========================================================
+
+function t2sFindWord(time) {{
+
+    // First try current word.
+    // This prevents unnecessary jumping.
+
+    if (
+        t2sCurrentWord >= 0 &&
+        t2sCurrentWord <
+            t2sWords.length
+    ) {{
+
+        const current =
+            t2sWords[
+                t2sCurrentWord
+            ];
+
+        const start =
+            parseFloat(
+                current.dataset.start
+            );
+
+        const end =
+            parseFloat(
+                current.dataset.end
+            );
+
+        if (
+            time >= start &&
+            time < end
+        ) {{
+            return t2sCurrentWord;
+        }}
+
+    }}
+
+
+    // Search all words
+
+    for (
+        let i = 0;
+        i < t2sWords.length;
+        i++
+    ) {{
+
+        const word =
+            t2sWords[i];
+
+        const start =
+            parseFloat(
+                word.dataset.start
+            );
+
+        const end =
+            parseFloat(
+                word.dataset.end
+            );
+
+        if (
+            time >= start &&
+            time < end
+        ) {{
+            return i;
+        }}
+
+    }}
+
+    // If audio is between words,
+    // use the next word.
+
+    for (
+        let i = 0;
+        i < t2sWords.length;
+        i++
+    ) {{
+
+        const start =
+            parseFloat(
+                t2sWords[i]
+                    .dataset
+                    .start
+            );
+
+        if (
+            time < start
+        ) {{
+            return i;
+        }}
+
+    }}
+
+    return -1;
+
+}}
+
+
+// =========================================================
+// AUDIO TIME UPDATE
+// =========================================================
+
+t2sAudio.addEventListener(
+    "timeupdate",
+    function() {{
+
+        const time =
+            t2sAudio.currentTime;
+
+        const index =
+            t2sFindWord(time);
+
+        if (
+            index >= 0 &&
+            index !== t2sCurrentWord
+        ) {{
+
+            t2sSetWord(
+                index
+            );
+
+        }}
+
+    }}
+);
+
+
+// =========================================================
+// CLICK WORD
+// =========================================================
+
+t2sWords.forEach(
+    function(word, index) {{
+
+        word.addEventListener(
+            "click",
+            function() {{
+
+                // IMPORTANT:
+                // Use index, NOT index - 1
+
+                t2sSetWord(
+                    index
+                );
+
+                // Start exactly at
+                // clicked word
+
+                const startTime =
+                    parseFloat(
+                        word.dataset.start
+                    );
+
+                if (
+                    !isNaN(startTime)
+                ) {{
+
+                    t2sAudio.currentTime =
+                        startTime;
+
+                }}
+
+                const playPromise =
+                    t2sAudio.play();
+
+                if (
+                    playPromise !==
+                    undefined
+                ) {{
+
+                    playPromise.catch(
+                        function(error) {{
+
+                            console.log(
+                                "Audio play error:",
+                                error
+                            );
+
+                        }}
+                    );
+
+                }}
+
+            }}
+        );
+
+    }}
+);
+
+
+// =========================================================
+// PREVIOUS WORD
+// =========================================================
+
+document
+    .getElementById(
+        "t2sPrevious"
+    )
+    .addEventListener(
+        "click",
+        function() {{
+
+            if (
+                t2sCurrentWord <= 0
+            ) {{
+                return;
+            }}
+
+            const index =
+                t2sCurrentWord - 1;
+
+            const word =
+                t2sWords[index];
+
+            t2sSetWord(
+                index
+            );
+
+            t2sAudio.currentTime =
+                parseFloat(
+                    word.dataset.start
+                );
+
+            t2sAudio.play();
+
+        }}
+    );
+
+
+// =========================================================
+// NEXT WORD
+// =========================================================
+
+document
+    .getElementById(
+        "t2sNext"
+    )
+    .addEventListener(
+        "click",
+        function() {{
+
+            if (
+                t2sCurrentWord >=
+                t2sWords.length - 1
+            ) {{
+                return;
+            }}
+
+            const index =
+                t2sCurrentWord + 1;
+
+            const word =
+                t2sWords[index];
+
+            t2sSetWord(
+                index
+            );
+
+            t2sAudio.currentTime =
+                parseFloat(
+                    word.dataset.start
+                );
+
+            t2sAudio.play();
+
+        }}
+    );
+
+
+// =========================================================
+// REPEAT CURRENT WORD
+// =========================================================
+
+document
+    .getElementById(
+        "t2sRepeat"
+    )
+    .addEventListener(
+        "click",
+        function() {{
+
+            if (
+                t2sCurrentWord < 0 ||
+                t2sCurrentWord >=
+                    t2sWords.length
+            ) {{
+                return;
+            }}
+
+            const word =
+                t2sWords[
+                    t2sCurrentWord
+                ];
+
+            const start =
+                parseFloat(
+                    word.dataset.start
+                );
+
+            const end =
+                parseFloat(
+                    word.dataset.end
+                );
+
+            t2sAudio.currentTime =
+                start;
+
+            t2sAudio.play();
+
+            // Stop at end of word
+
+            function stopAtEnd() {{
+
+                if (
+                    t2sAudio.currentTime >=
+                    end
+                ) {{
+
+                    t2sAudio.pause();
+
+                    t2sAudio.currentTime =
+                        start;
+
+                    t2sAudio.removeEventListener(
+                        "timeupdate",
+                        stopAtEnd
+                    );
+
+                }}
+
+            }}
+
+            t2sAudio.addEventListener(
+                "timeupdate",
+                stopAtEnd
+            );
+
+        }}
+    );
+
+
+// =========================================================
+// PLAY / PAUSE
+// =========================================================
+
+document
+    .getElementById(
+        "t2sPlayPause"
+    )
+    .addEventListener(
+        "click",
+        function() {{
+
+            if (
+                t2sAudio.paused
+            ) {{
+
+                t2sAudio.play();
+
+            }}
+            else {{
+
+                t2sAudio.pause();
+
+            }}
+
+        }}
+    );
+
+
+// =========================================================
+// SPEED
+// =========================================================
+
+document
+    .getElementById(
+        "t2sSpeed"
+    )
+    .addEventListener(
+        "change",
+        function() {{
+
+            t2sAudio.playbackRate =
+                parseFloat(
+                    this.value
+                );
+
+        }}
+    );
+
+
+// =========================================================
+// AUDIO ENDED
+// =========================================================
+
+t2sAudio.addEventListener(
+    "ended",
+    function() {{
+
+        // Remove highlight
+
+        t2sWords.forEach(
+            function(word) {{
+
+                word.classList.remove(
+                    "active"
+                );
+
+            }}
+        );
+
+        // Reset
+
+        t2sCurrentWord = -1;
+
+    }}
+);
+
+
+// =========================================================
+// INITIAL STATE
+// =========================================================
+
+t2sAudio.playbackRate = {self.speed};
+
+</script>
+
+
+</body>
+
+</html>
+"""
+
+        display(
+            HTML(page)
+        )
+
+
+def male_voice():
+    male = ["am_michael", "am_fenrir", "am_puck", "am_echo", "am_eric", "am_liam", "am_onyx", "am_santa", "am_adam","bm_george", "bm_fable", "bm_lewis", "bm_daniel"]
+    return male
+
+def female_voice():
+    female = ["af_heart" , "af_bella" , "af_nicole" , "af_aoede", "af_kore", "af_sarah", "af_nova", "af_sky", "af_alloy", "af_jessica", "af_river","bf_emma", "bf_isabella", "bf_alice", "bf_lily"]
+    return female
+
+
+def exec(filename="example",speed=1.0,voice="am_santa",isReadView=True):
+ t2s = T2S(filename=f"{filename}.txt",speed=speed,voice=voice)
+ t2s.generate(f"{filename}.wav")
+ if isReadView:
+  t2s.display()
+  t2s.reader()
+ return t2s