ttsforge 0.1.0__py3-none-any.whl

ttsforge/input_reader.py

@@ -0,0 +1,408 @@
+"""Unified input file reader for EPUB, TXT, and SSMD files.
+
+This module provides a common interface for reading different input formats,
+extracting metadata, chapters, and content for TTS conversion.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .utils import detect_encoding
+
+
+@dataclass
+class Metadata:
+    """Book metadata."""
+
+    title: str | None = None
+    authors: list[str] = field(default_factory=list)
+    language: str | None = None
+    publisher: str | None = None
+    publication_year: int | None = None
+
+
+@dataclass
+class Chapter:
+    """Represents a chapter with title and content."""
+
+    title: str
+    text: str
+    index: int = 0
+    is_ssmd: bool = False
+
+    @property
+    def char_count(self) -> int:
+        """Return the character count of the chapter."""
+        return len(self.text)
+
+    @property
+    def content(self) -> str:
+        """Alias for text to maintain compatibility with conversion.Chapter."""
+        return self.text
+
+
+class InputReader:
+    """Unified reader for EPUB, TXT (Gutenberg), and SSMD files."""
+
+    def __init__(self, file_path: Path | str):
+        """Initialize the reader with a file path.
+
+        Args:
+            file_path: Path to the input file (EPUB, TXT, or SSMD)
+        """
+        self.file_path = Path(file_path)
+        self._metadata: Metadata | None = None
+        self._chapters: list[Chapter] | None = None
+
+        if not self.file_path.exists():
+            raise FileNotFoundError(f"File not found: {self.file_path}")
+
+        # Determine file type
+        self.file_type = self._detect_file_type()
+
+    def _detect_file_type(self) -> str:
+        """Detect the file type based on extension.
+
+        Returns:
+            File type: 'epub', 'txt', or 'ssmd'
+        """
+        suffix = self.file_path.suffix.lower()
+        if suffix == ".epub":
+            return "epub"
+        elif suffix == ".ssmd":
+            return "ssmd"
+        elif suffix in [".txt", ".text"]:
+            return "txt"
+        elif suffix == ".pdf":
+            raise ValueError(
+                "PDF input is not supported yet. Convert the PDF to EPUB or TXT "
+                "and try again."
+            )
+        else:
+            raise ValueError(
+                f"Unsupported file type: {suffix}. Supported types: .epub, .txt, .ssmd"
+            )
+
+    def get_metadata(self) -> Metadata:
+        """Extract metadata from the file.
+
+        Returns:
+            Metadata object with title, author, language, etc.
+        """
+        if self._metadata is not None:
+            return self._metadata
+
+        if self.file_type == "epub":
+            self._metadata = self._get_epub_metadata()
+        elif self.file_type == "txt":
+            self._metadata = self._get_gutenberg_metadata()
+        elif self.file_type == "ssmd":
+            self._metadata = self._get_ssmd_metadata()
+        elif self.file_type == "pdf":
+            raise ValueError("PDF input is not supported yet.")
+
+        if self._metadata is None:
+            raise ValueError("Metadata could not be loaded")
+        return self._metadata
+
+    def get_chapters(self) -> list[Chapter]:
+        """Extract chapters from the file.
+
+        Returns:
+            List of Chapter objects
+        """
+        if self._chapters is not None:
+            return self._chapters
+
+        if self.file_type == "epub":
+            self._chapters = self._get_epub_chapters()
+        elif self.file_type == "txt":
+            self._chapters = self._get_gutenberg_chapters()
+        elif self.file_type == "ssmd":
+            self._chapters = self._get_ssmd_chapters()
+        elif self.file_type == "pdf":
+            raise ValueError("PDF input is not supported yet.")
+
+        if self._chapters is None:
+            raise ValueError("Chapters could not be loaded")
+        return self._chapters
+
+    def get_chapters_with_html(self) -> list[tuple[Chapter, str | None]]:
+        """Extract chapters with their original HTML content for markup detection.
+
+        Returns:
+            List of tuples containing (Chapter, html_content or None)
+        """
+        if self.file_type == "epub":
+            return self._get_epub_chapters_with_html()
+        else:
+            # For non-EPUB files, HTML content is not available
+            chapters = self.get_chapters()
+            return [(ch, None) for ch in chapters]
+
+    # EPUB methods
+    def _get_epub_metadata(self) -> Metadata:
+        """Extract metadata from EPUB file."""
+        try:
+            from epub2text import EPUBParser
+        except ImportError as e:
+            raise ImportError(
+                "epub2text is required for EPUB support. "
+                "Install with: pip install epub2text"
+            ) from e
+
+        parser = EPUBParser(str(self.file_path))
+        epub_metadata = parser.get_metadata()
+
+        raw_year: object = epub_metadata.publication_year
+        publication_year: int | None = None
+        if isinstance(raw_year, int):
+            publication_year = raw_year
+        elif isinstance(raw_year, str):
+            try:
+                publication_year = int(raw_year)
+            except ValueError:
+                publication_year = None
+
+        return Metadata(
+            title=epub_metadata.title,
+            authors=list(epub_metadata.authors) if epub_metadata.authors else [],
+            language=epub_metadata.language,
+            publisher=epub_metadata.publisher,
+            publication_year=publication_year,
+        )
+
+    def _get_epub_chapters(self) -> list[Chapter]:
+        """Extract chapters from EPUB file."""
+        try:
+            from epub2text import EPUBParser
+        except ImportError as e:
+            raise ImportError(
+                "epub2text is required for EPUB support. "
+                "Install with: pip install epub2text"
+            ) from e
+
+        parser = EPUBParser(str(self.file_path))
+        epub_chapters = parser.get_chapters()
+
+        # Convert to our Chapter format
+        chapters = []
+        for i, ch in enumerate(epub_chapters):
+            # Remove <<CHAPTER: ...>> markers that epub2text adds
+            content = re.sub(
+                r"^\s*<<CHAPTER:[^>]*>>\s*\n*", "", ch.text, count=1, flags=re.MULTILINE
+            )
+            chapters.append(Chapter(title=ch.title, text=content, index=i))
+
+        return chapters
+
+    def _get_epub_chapters_with_html(self) -> list[tuple[Chapter, str | None]]:
+        """Extract chapters from EPUB with HTML content preserved."""
+        try:
+            from epub2text import EPUBParser
+        except ImportError as e:
+            raise ImportError(
+                "epub2text is required for EPUB support. "
+                "Install with: pip install epub2text"
+            ) from e
+
+        parser = EPUBParser(str(self.file_path))
+        epub_chapters = parser.get_chapters()
+
+        # Convert to our Chapter format with HTML
+        chapters_with_html = []
+        for i, ch in enumerate(epub_chapters):
+            # Remove <<CHAPTER: ...>> markers from plain text
+            content = re.sub(
+                r"^\s*<<CHAPTER:[^>]*>>\s*\n*", "", ch.text, count=1, flags=re.MULTILINE
+            )
+            chapter = Chapter(title=ch.title, text=content, index=i)
+
+            # Try to get HTML content
+            # epub2text may have an html attribute or we need to extract it
+            html_content = getattr(ch, "html", None)
+            if html_content is None:
+                html_content = getattr(ch, "content", None)
+
+            chapters_with_html.append((chapter, html_content))
+
+        return chapters_with_html
+
+    # Gutenberg TXT methods
+    def _get_gutenberg_metadata(self) -> Metadata:
+        """Extract metadata from Project Gutenberg TXT file.
+
+        Parses the header of a Gutenberg text file to extract metadata.
+        """
+        encoding = detect_encoding(self.file_path)
+        with open(self.file_path, encoding=encoding, errors="replace") as f:
+            # Read first 1000 lines for metadata (Gutenberg header is typically short)
+            header_lines = []
+            for i, line in enumerate(f):
+                if i >= 1000:
+                    break
+                header_lines.append(line)
+                # Stop at start of content
+                if "*** START OF" in line.upper():
+                    break
+
+        header_text = "".join(header_lines)
+
+        # Extract metadata using regex
+        title = None
+        authors = []
+        language = None
+
+        # Title pattern: "Title: <title>"
+        title_match = re.search(
+            r"^Title:\s*(.+)$", header_text, re.MULTILINE | re.IGNORECASE
+        )
+        if title_match:
+            title = title_match.group(1).strip()
+
+        # Author pattern: "Author: <author>"
+        author_match = re.search(
+            r"^Author:\s*(.+)$", header_text, re.MULTILINE | re.IGNORECASE
+        )
+        if author_match:
+            authors = [author_match.group(1).strip()]
+
+        # Language pattern: "Language: <language>"
+        lang_match = re.search(
+            r"^Language:\s*(.+)$", header_text, re.MULTILINE | re.IGNORECASE
+        )
+        if lang_match:
+            language = lang_match.group(1).strip()
+
+        return Metadata(title=title, authors=authors, language=language)
+
+    def _get_gutenberg_chapters(self) -> list[Chapter]:
+        """Extract chapters from Project Gutenberg TXT file.
+
+        Splits the text into chapters based on common patterns like:
+        - "CHAPTER I", "CHAPTER 1", "Chapter One"
+        - "ONE", "TWO", etc. (capitalized chapter titles)
+        - "PART I", etc.
+        """
+        encoding = detect_encoding(self.file_path)
+        with open(self.file_path, encoding=encoding, errors="replace") as f:
+            full_text = f.read()
+
+        # Find the start and end markers
+        start_match = re.search(
+            r"\*\*\* START OF (?:THE|THIS) (?:PROJECT )?GUTENBERG (?:EBOOK|E-BOOK)",
+            full_text,
+            re.IGNORECASE,
+        )
+        end_match = re.search(
+            r"\*\*\* END OF (?:THE|THIS) (?:PROJECT )?GUTENBERG (?:EBOOK|E-BOOK)",
+            full_text,
+            re.IGNORECASE,
+        )
+
+        # Extract content between markers
+        if start_match:
+            start_pos = start_match.end()
+        else:
+            start_pos = 0
+
+        if end_match:
+            end_pos = end_match.start()
+        else:
+            end_pos = len(full_text)
+
+        content = full_text[start_pos:end_pos].strip()
+
+        # Try to split by chapters
+        # Pattern 1: "CHAPTER X" or "Chapter X" at start of line
+        chapter_pattern = re.compile(
+            r"^(?:CHAPTER|Chapter|PART|Part)\s+(?:[IVXLCDM]+|\d+|[A-Z][A-Z\s-]+)$",
+            re.MULTILINE,
+        )
+
+        # Find all chapter markers
+        chapter_matches = list(chapter_pattern.finditer(content))
+
+        if len(chapter_matches) > 1:
+            # We found chapters, split by them
+            chapters = []
+            for i, match in enumerate(chapter_matches):
+                title = match.group(0).strip()
+                start = match.end()
+                end = (
+                    chapter_matches[i + 1].start()
+                    if i + 1 < len(chapter_matches)
+                    else len(content)
+                )
+                text = content[start:end].strip()
+
+                if text:  # Only add non-empty chapters
+                    chapters.append(Chapter(title=title, text=text, index=i))
+
+            return chapters
+        else:
+            # No clear chapter structure, check for numbered sections
+            # Pattern 2: Single words in all caps on own line
+            # (like "ONE", "TWO", etc.)
+            section_pattern = re.compile(r"^([A-Z][A-Z\s-]{2,})$", re.MULTILINE)
+            section_matches = list(section_pattern.finditer(content))
+
+            # Filter to likely chapter titles (not too long, appear multiple times)
+            if len(section_matches) >= 3:
+                chapters = []
+                for i, match in enumerate(section_matches):
+                    title = match.group(0).strip()
+                    start = match.end()
+                    end = (
+                        section_matches[i + 1].start()
+                        if i + 1 < len(section_matches)
+                        else len(content)
+                    )
+                    text = content[start:end].strip()
+
+                    if text and len(text) > 100:  # Only add substantial sections
+                        chapters.append(Chapter(title=title, text=text, index=i))
+
+                if chapters:
+                    return chapters
+
+            # No chapter structure found, return entire content as one chapter
+            metadata = self.get_metadata()
+            title = metadata.title or self.file_path.stem
+            return [Chapter(title=title, text=content, index=0)]
+
+    def _get_ssmd_metadata(self) -> Metadata:
+        """Extract metadata from an SSMD file."""
+        return Metadata(title=self.file_path.stem, authors=[], language=None)
+
+    def _get_ssmd_chapters(self) -> list[Chapter]:
+        """Read an SSMD file as a single chapter."""
+        encoding = detect_encoding(self.file_path)
+        with open(self.file_path, encoding=encoding, errors="replace") as f:
+            content = f.read()
+        return [
+            Chapter(
+                title=self.file_path.stem,
+                text=content,
+                index=0,
+                is_ssmd=True,
+            )
+        ]
+
+    # PDF methods (placeholder for future implementation)
+    def _get_pdf_metadata(self) -> Metadata:
+        """Extract metadata from PDF file.
+
+        TODO: Implement PDF metadata extraction.
+        """
+        raise NotImplementedError("PDF support is not yet implemented")
+
+    def _get_pdf_chapters(self) -> list[Chapter]:
+        """Extract chapters from PDF file.
+
+        TODO: Implement PDF chapter extraction.
+        """
+        raise NotImplementedError("PDF support is not yet implemented")

ttsforge/kokoro_lang.py

@@ -0,0 +1,12 @@
+# ttsforge/kokoro_lang.py
+from __future__ import annotations
+
+
+def get_onnx_lang_code(ttsforge_lang: str) -> str:
+    """Convert ttsforge language code to kokoro ONNX language code."""
+    from pykokoro.onnx_backend import LANG_CODE_TO_ONNX
+
+    lang = LANG_CODE_TO_ONNX.get(ttsforge_lang)
+    if isinstance(lang, str):
+        return lang
+    return ttsforge_lang or "en-us"

ttsforge/kokoro_runner.py

@@ -0,0 +1,125 @@
+# ttsforge/kokoro_runner.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal, Protocol, cast
+
+import numpy as np
+from pykokoro import GenerationConfig, KokoroPipeline, PipelineConfig
+from pykokoro.onnx_backend import (
+    Kokoro,
+    VoiceBlend,
+    are_models_downloaded,
+    download_all_models,
+)
+from pykokoro.stages.audio_generation.onnx import OnnxAudioGenerationAdapter
+from pykokoro.stages.audio_postprocessing.onnx import OnnxAudioPostprocessingAdapter
+from pykokoro.stages.phoneme_processing.onnx import OnnxPhonemeProcessorAdapter
+
+
+@dataclass(slots=True)
+class KokoroRunOptions:
+    voice: str
+    speed: float
+    use_gpu: bool
+    pause_clause: float
+    pause_sentence: float
+    pause_paragraph: float
+    pause_variance: float
+    model_path: Any | None = None
+    voices_path: Any | None = None
+    voice_blend: str | None = None
+    voice_database: Any | None = None
+    tokenizer_config: Any | None = None  # pykokoro.tokenizer.TokenizerConfig
+
+
+class KokoroRunner:
+    class LogCallback(Protocol):
+        def __call__(self, message: str, level: str = "info") -> None: ...
+
+    def __init__(self, opts: KokoroRunOptions, log: LogCallback):
+        self.opts = opts
+        self.log = log
+        self._kokoro: Kokoro | None = None
+        self._pipeline: KokoroPipeline | None = None
+        self._voice_style: str | VoiceBlend | None = None
+
+    def ensure_ready(self) -> None:
+        if self._pipeline is not None:
+            return
+
+        if not are_models_downloaded():
+            self.log("Downloading ONNX model files...")
+            download_all_models()
+
+        self._kokoro = Kokoro(
+            model_path=self.opts.model_path,
+            voices_path=self.opts.voices_path,
+            use_gpu=self.opts.use_gpu,
+            tokenizer_config=self.opts.tokenizer_config,
+        )
+
+        assert self._kokoro is not None
+
+        if self.opts.voice_database:
+            try:
+                self._kokoro.load_voice_database(self.opts.voice_database)
+                self.log(f"Loaded voice database: {self.opts.voice_database}")
+            except Exception as e:
+                self.log(f"Failed to load voice database: {e}", "warning")
+
+        if self.opts.voice_blend:
+            self._voice_style = VoiceBlend.parse(self.opts.voice_blend)
+        else:
+            # if voice_database provides overrides, let Kokoro resolve it
+            if self.opts.voice_database:
+                db_voice = cast(
+                    str | VoiceBlend | None,
+                    self._kokoro.get_voice_from_database(self.opts.voice),
+                )
+                self._voice_style = (
+                    db_voice if db_voice is not None else self.opts.voice
+                )
+            else:
+                self._voice_style = self.opts.voice
+
+        # GenerationConfig will be supplied per call
+        # because lang / is_phonemes can vary
+        pipeline_cfg = PipelineConfig(
+            voice=self._voice_style,
+            generation=GenerationConfig(speed=self.opts.speed, lang="en-us"),
+            model_path=self.opts.model_path,
+            voices_path=self.opts.voices_path,
+            tokenizer_config=self.opts.tokenizer_config,
+        )
+
+        # Use the same adapters everywhere (text + phonemes)
+        self._pipeline = KokoroPipeline(
+            pipeline_cfg,
+            phoneme_processing=OnnxPhonemeProcessorAdapter(self._kokoro),
+            audio_generation=OnnxAudioGenerationAdapter(self._kokoro),
+            audio_postprocessing=OnnxAudioPostprocessingAdapter(self._kokoro),
+        )
+
+    def synthesize(
+        self,
+        text_or_ssmd: str,
+        *,
+        lang_code: str,
+        pause_mode: Literal["tts", "manual", "auto"],
+        is_phonemes: bool = False,
+    ) -> np.ndarray:
+        self.ensure_ready()
+        assert self._pipeline is not None
+        gen = GenerationConfig(
+            speed=self.opts.speed,
+            lang=lang_code,
+            is_phonemes=is_phonemes,
+            pause_mode=pause_mode,
+            pause_clause=self.opts.pause_clause,
+            pause_sentence=self.opts.pause_sentence,
+            pause_paragraph=self.opts.pause_paragraph,
+            pause_variance=self.opts.pause_variance,
+        )
+        audio = self._pipeline.run(text_or_ssmd, generation=gen).audio
+        return cast(np.ndarray, audio)