epub2text 0.2.2__tar.gz → 0.2.4__tar.gz

epub2text-0.2.4/.codecrate.toml

@@ -0,0 +1,10 @@
+[codecrate]
+output = "context_epub2text.md"
+keep_docstrings = true
+dedupe = true
+metadata = false
+respect_gitignore = true
+exclude = ["examples", "*/.venv/*"]
+include = ["**/*.py", "**/*.toml", "**/*.rst", "**/*.md"]
+split_max_chars = 0
+layout = "full"

{epub2text-0.2.2 → epub2text-0.2.4}/.gitignore

@@ -206,3 +206,4 @@ marimo/_static/
 marimo/_lsp/
 __marimo__/
 epub2text/_version.py
+context_epub2text.md

{epub2text-0.2.2 → epub2text-0.2.4}/.ruff.toml

@@ -1,5 +1,5 @@
 
-target-version = "py39"
+target-version = "py310"
 fix = true
 
 [lint]

{epub2text-0.2.2 → epub2text-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epub2text
-Version: 0.2.2
+Version: 0.2.4
 Summary: A simple tool to extract text from EPUB files.
 Author-email: Holger Nahrstaedt <nahrstaedt@gmail.com>
 License: MIT License
@@ -37,7 +37,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0.0
@@ -45,10 +45,9 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: ebooklib>=0.18
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: phrasplit>=0.3.2
 Provides-Extra: lxml
 Requires-Dist: lxml>=4.9.0; extra == "lxml"
-Provides-Extra: sentences
-Requires-Dist: phrasplit>=0.1.0; extra == "sentences"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"

{epub2text-0.2.2 → epub2text-0.2.4}/docs/installation.rst

@@ -31,10 +31,6 @@ For better HTML parsing performance::
 
     pip install epub2text[lxml]
 
-For sentence-level formatting (requires phrasplit/spaCy)::
-
-    pip install epub2text[sentences]
-
 After installing, download a spaCy language model::
 
     python -m spacy download en_core_web_sm

{epub2text-0.2.2 → epub2text-0.2.4}/docs/make.py

@@ -20,7 +20,7 @@ import subprocess
 import sys
 
 
-def main():
+def main() -> int:
     """Run the script."""
     sphinx_build = "sphinx-build"
     build_dir = os.path.join("docs", "build")

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/__init__.py

@@ -136,7 +136,7 @@ def _download_epub(
     except Exception as exc:
         if tmp_path:
             Path(tmp_path).unlink(missing_ok=True)
-        if isinstance(exc, (urllib.error.URLError, socket.timeout)):
+        if isinstance(exc, urllib.error.URLError | socket.timeout):
             if isinstance(exc, socket.timeout) or isinstance(
                 getattr(exc, "reason", None), socket.timeout
             ):
@@ -152,7 +152,7 @@ def epub2txt(
     max_bytes: int = DEFAULT_MAX_DOWNLOAD_BYTES,
     user_agent: str | None = None,
     allowed_schemes: tuple[str, ...] = ("https", "http"),
-) -> Union[str, list[str]]:
+) -> str | list[str]:
     """
     Extract text from EPUB file (compatibility function for old epub2txt API).
 

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
 
-__commit_id__ = commit_id = 'ga27a7539e'
+__commit_id__ = commit_id = 'ge900e4fef'

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/bookmarks.py

@@ -7,7 +7,7 @@ import tempfile
 from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, cast
 
 logger = logging.getLogger(__name__)
 
@@ -54,7 +54,7 @@ class Bookmark:
 class BookmarkManager:
     """Manages bookmarks for EPUB files."""
 
-    def __init__(self, bookmark_file: Optional[Path] = None) -> None:
+    def __init__(self, bookmark_file: Path | None = None) -> None:
         """
         Initialize bookmark manager.
 
@@ -119,11 +119,15 @@ class BookmarkManager:
         """Return the path for the bookmark backup file."""
         return self.bookmark_file.with_suffix(self.bookmark_file.suffix + ".bak")
 
-    def _read_bookmarks_file(self, path: Path) -> Optional[dict[str, Any]]:
+    def _read_bookmarks_file(self, path: Path) -> dict[str, Any] | None:
         """Read bookmarks JSON from disk."""
         try:
             with open(path, encoding="utf-8") as f:
-                return json.load(f)
+                data = json.load(f)
+            if isinstance(data, dict):
+                return cast(dict[str, Any], data)
+            logger.warning("Unexpected bookmark data structure in %s", path)
+            return None
         except (json.JSONDecodeError, OSError) as exc:
             logger.warning("Failed to load bookmarks from %s: %s", path, exc)
             return None
@@ -144,7 +148,7 @@ class BookmarkManager:
         self._bookmarks[key] = asdict(bookmark)
         self._save()
 
-    def load(self, epub_path: str) -> Optional[Bookmark]:
+    def load(self, epub_path: str) -> Bookmark | None:
         """
         Load bookmark for a specific EPUB file.
 

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/cleaner.py

@@ -96,7 +96,7 @@ class TextCleaner:
         markers = {}
         marker_count = [0]
 
-        def save_marker(match):
+        def save_marker(match: re.Match[str]) -> str:
             placeholder = f"___MARKER_{marker_count[0]}___"
             markers[placeholder] = match.group(0)
             marker_count[0] += 1
@@ -147,8 +147,6 @@ class TextCleaner:
     def apply_gutenberg_spacing(self, text: str) -> str:
         """Apply Gutenberg Project formatting: two spaces after sentences and colons.
 
-        Uses phrasplit for accurate sentence boundary detection.
-
         Args:
             text: Text to format
 
@@ -198,7 +196,7 @@ class TextCleaner:
         abbrev_map = {}
         abbrev_counter = [0]
 
-        def protect_abbrev(match):
+        def protect_abbrev(match: re.Match[str]) -> str:
             placeholder = f"__ABBREV_{abbrev_counter[0]}__"
             abbrev_map[placeholder] = match.group(0)
             abbrev_counter[0] += 1

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/cli.py

@@ -7,7 +7,6 @@ import sys
 from collections.abc import Iterator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Optional
 
 import click
 from rich.console import Console
@@ -46,7 +45,7 @@ def spinner(task_description: str) -> Iterator[None]:
         yield
 
 
-def parse_range_tokens(range_str: str) -> list[tuple[str, Optional[str]]]:
+def parse_range_tokens(range_str: str) -> list[tuple[str, str | None]]:
     """
     Parse a range string into ordered tokens.
 
@@ -59,7 +58,7 @@ def parse_range_tokens(range_str: str) -> list[tuple[str, Optional[str]]]:
     if not range_str:
         raise ValueError("Range string cannot be empty")
 
-    tokens: list[tuple[str, Optional[str]]] = []
+    tokens: list[tuple[str, str | None]] = []
     parts = range_str.split(",")
 
     for part in parts:
@@ -205,7 +204,7 @@ def parse_page_range(range_str: str, pages: list[Page]) -> list[str]:
     result: list[str] = []
     seen: set[str] = set()
 
-    def parse_int(value: str) -> Optional[int]:
+    def parse_int(value: str) -> int | None:
         try:
             return int(value)
         except ValueError:
@@ -590,8 +589,8 @@ def list_pages(filepath: Path, page_size: int, use_words: bool) -> None:
 )
 def extract_pages_cmd(
     filepath: Path,
-    output: Optional[Path],
-    pages: Optional[str],
+    output: Path | None,
+    pages: str | None,
     page_size: int,
     use_words: bool,
     raw: bool,
@@ -786,13 +785,13 @@ def extract_pages_cmd(
 )
 def extract(
     filepath: Path,
-    output: Optional[Path],
-    chapters: Optional[str],
+    output: Path | None,
+    chapters: str | None,
     interactive: bool,
     paragraphs: bool,
     sentences: bool,
     comma: bool,
-    max_length: Optional[int],
+    max_length: int | None,
     empty_lines: bool,
     separator: str,
     raw: bool,
@@ -801,7 +800,7 @@ def extract(
     no_markers: bool,
     language_model: str,
     offset: int,
-    limit: Optional[int],
+    limit: int | None,
     line_numbers: bool,
 ) -> None:
     """
@@ -1012,8 +1011,8 @@ def extract(
 )
 def extract_gutenberg(
     filepath: Path,
-    output: Optional[Path],
-    chapters: Optional[str],
+    output: Path | None,
+    chapters: str | None,
     interactive: bool,
 ) -> None:
     """
@@ -1124,9 +1123,9 @@ def extract_gutenberg(
             # First, normalize the chapter text to help with splitting
             chapter_lines = chapter_text.split("\n")
 
-            current_title = None
-            current_content = []
-            chapters_list = []
+            current_title: str | None = None
+            current_content: list[str] = []
+            chapters_list: list[tuple[str, str]] = []
 
             i = 0
             while i < len(chapter_lines):
@@ -1418,11 +1417,11 @@ def info(filepath: Path, format: str) -> None:
 )
 def read(
     filepath: Path,
-    chapter: Optional[int],
-    line: Optional[int],
+    chapter: int | None,
+    line: int | None,
     resume: bool,
-    bookmark_file: Optional[Path],
-    page_size: Optional[int],
+    bookmark_file: Path | None,
+    page_size: int | None,
     no_header: bool,
     no_footer: bool,
     sentences: bool,
@@ -1432,7 +1431,7 @@ def read(
     raw: bool,
     keep_footnotes: bool,
     keep_page_numbers: bool,
-    width: Optional[int],
+    width: int | None,
 ) -> None:
     """
     Interactively read an EPUB file in the terminal.

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/formatters.py

@@ -1,70 +1,15 @@
 """Text formatting utilities for different output styles."""
 
 import re
-from typing import Callable, Optional
-
-# Type aliases for phrasplit functions
-_SplitFunc = Callable[[str, str], list[str]]
-_SplitLongLinesFunc = Callable[[str, int, str], list[str]]
-
-# Try to import phrasplit, fall back to None when not available
-PHRASPLIT_AVAILABLE: bool
-phrasplit_clauses: Optional[_SplitFunc]
-phrasplit_long_lines: Optional[_SplitLongLinesFunc]
-phrasplit_paragraphs: Optional[Callable[[str], list[str]]]
-phrasplit_sentences: Optional[_SplitFunc]
-
-try:
-    from phrasplit import (  # type: ignore[import-not-found]
-        split_clauses as _phrasplit_clauses,
-    )
-    from phrasplit import (
-        split_long_lines as _phrasplit_long_lines,
-    )
-    from phrasplit import (
-        split_paragraphs as _phrasplit_paragraphs,
-    )
-    from phrasplit import (
-        split_sentences as _phrasplit_sentences,
-    )
-
-    PHRASPLIT_AVAILABLE = True
-    phrasplit_clauses = _phrasplit_clauses
-    phrasplit_long_lines = _phrasplit_long_lines
-    phrasplit_paragraphs = _phrasplit_paragraphs
-    phrasplit_sentences = _phrasplit_sentences
-except ImportError:
-    PHRASPLIT_AVAILABLE = False
-    phrasplit_clauses = None
-    phrasplit_long_lines = None
-    phrasplit_paragraphs = None
-    phrasplit_sentences = None
-
-
-def _check_phrasplit() -> None:
-    """Check if phrasplit is available, raise ImportError if not."""
-    if not PHRASPLIT_AVAILABLE:
-        raise ImportError(
-            "phrasplit is required for this feature. "
-            "Install with: pip install epub2text[sentences]"
-        )
-
-
-def split_paragraphs(text: str) -> list[str]:
-    """
-    Split text into paragraphs (separated by double newlines).
 
-    This function works without phrasplit by using a simple regex split.
-
-    Args:
-        text: Input text
-
-    Returns:
-        List of paragraphs (non-empty, stripped)
-    """
-    # Simple implementation that doesn't require phrasplit
-    paragraphs = re.split(r"\n\s*\n", text)
-    return [p.strip() for p in paragraphs if p.strip()]
+from phrasplit import (
+    split_clauses,
+    split_paragraphs,
+    split_sentences,
+)
+from phrasplit import (
+    split_long_lines as _phrasplit_split_long_lines,
+)
 
 
 def collapse_paragraph(paragraph: str) -> str:
@@ -146,8 +91,6 @@ def format_sentences(
     """
     Format text with one sentence per line.
 
-    Requires phrasplit to be installed.
-
     Args:
         text: Input text with paragraph breaks
         separator: String to prepend at paragraph boundaries (default: "  ")
@@ -157,9 +100,6 @@ def format_sentences(
         Text with one sentence per line, separator at paragraph boundaries.
         Chapter titles are preserved.
     """
-    _check_phrasplit()
-    assert phrasplit_sentences is not None
-
     paragraphs = split_paragraphs(text)
 
     if not paragraphs:
@@ -180,7 +120,7 @@ def format_sentences(
             continue
 
         # Process paragraph into sentences using phrasplit
-        sentences = phrasplit_sentences(para, language_model)
+        sentences = split_sentences(para, language_model)
 
         if not sentences:
             continue
@@ -224,8 +164,6 @@ def format_clauses(
             "I do like coffee,
             and I like wine."
     """
-    _check_phrasplit()
-    assert phrasplit_clauses is not None
 
     paragraphs = split_paragraphs(text)
 
@@ -246,7 +184,7 @@ def format_clauses(
             continue
 
         # Process paragraph into clauses using phrasplit
-        clauses = phrasplit_clauses(para, language_model)
+        clauses = split_clauses(para, language_model)
 
         if not clauses:
             continue
@@ -277,8 +215,6 @@ def split_long_lines(
     2. If still too long, split at clause boundaries (commas, semicolons, etc.)
     3. If still too long, split at word boundaries
 
-    Requires phrasplit to be installed.
-
     Args:
         text: Input text (may already be formatted)
         max_length: Maximum line length in characters
@@ -288,9 +224,6 @@ def split_long_lines(
     Returns:
         Text with long lines split. Chapter titles are preserved.
     """
-    _check_phrasplit()
-    assert phrasplit_long_lines is not None
-
     lines = text.split("\n")
     result_lines: list[str] = []
 
@@ -315,9 +248,13 @@ def split_long_lines(
         has_separator = line.startswith(separator) if separator else False
         content = line[len(separator) :] if has_separator else line
 
-        # Split the long line using phrasplit
-        split_lines_list = phrasplit_long_lines(content, max_length, language_model)
-
+        # Split the long line using phrasplit (avoid calling ourselves)
+        split_lines_list = _phrasplit_split_long_lines(
+            content, max_length, language_model
+        )
+        # Defensive: if upstream ever returns a string, normalize to list
+        if isinstance(split_lines_list, str):
+            split_lines_list = [split_lines_list]
         # Add separator to first line if original had it
         for k, split_line in enumerate(split_lines_list):
             if k == 0 and has_separator:
@@ -328,32 +265,11 @@ def split_long_lines(
     return "\n".join(result_lines)
 
 
-# Keep backward compatibility alias
-def format_as_sentences(text: str, language_model: str = "en_core_web_sm") -> str:
-    """
-    Format text with one sentence per line using spaCy.
-
-    Deprecated: Use format_sentences() instead.
-
-    Requires phrasplit to be installed.
-
-    Args:
-        text: Input text with paragraph breaks
-        language_model: spaCy language model to use (default: "en_core_web_sm")
-
-    Returns:
-        Text with sentences separated by newlines
-    """
-    return format_sentences(text, separator="", language_model=language_model)
-
-
 __all__ = [
-    "PHRASPLIT_AVAILABLE",
     "collapse_paragraph",
     "format_paragraphs",
     "format_sentences",
     "format_clauses",
     "split_long_lines",
-    "format_as_sentences",
     "split_paragraphs",
 ]

{epub2text-0.2.2 → epub2text-0.2.4}/epub2text/models.py

@@ -2,7 +2,6 @@
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Optional
 
 
 class PageSource(Enum):
@@ -25,8 +24,8 @@ class Page:
     text: str
     char_count: int
     source: PageSource
-    chapter_id: Optional[str] = None  # Which chapter this page belongs to
-    chapter_title: Optional[str] = None  # Title of the chapter
+    chapter_id: str | None = None  # Which chapter this page belongs to
+    chapter_title: str | None = None  # Title of the chapter
 
     def __str__(self) -> str:
         source_str = "print" if self.source == PageSource.EPUB_PAGE_LIST else "syn"
@@ -41,7 +40,7 @@ class Chapter:
     title: str
     text: str
     char_count: int
-    parent_id: Optional[str] = None
+    parent_id: str | None = None
     level: int = 0
 
     def __str__(self) -> str:
@@ -52,18 +51,18 @@ class Chapter:
 class Metadata:
     """EPUB metadata."""
 
-    title: Optional[str] = None
+    title: str | None = None
     authors: list[str] = field(default_factory=list)
-    publisher: Optional[str] = None
-    publication_year: Optional[str] = None
-    description: Optional[str] = None
+    publisher: str | None = None
+    publication_year: str | None = None
+    description: str | None = None
     # Required EPUB3 metadata
-    identifier: Optional[str] = None
-    language: Optional[str] = None
+    identifier: str | None = None
+    language: str | None = None
     # Optional Dublin Core metadata
     contributors: list[str] = field(default_factory=list)
-    rights: Optional[str] = None
-    coverage: Optional[str] = None
+    rights: str | None = None
+    coverage: str | None = None
 
     def __str__(self) -> str:
         lines = []