titlemark 1.2.0__py3-none-any.whl

titlemark/extractors/djvu.py

@@ -0,0 +1,100 @@
+"""Экстрактор DJVU: аннотации ANTa + текстовый слой через djvulibre.
+
+DjVu хранит текст в сжатых чанках TXTz (BZZ), извлечь их без djvulibre
+нельзя; если утилиты `djvutxt`/`ddjvu` установлены (пакет djvulibre),
+текст берётся из них, а для сканов работает OCR через ddjvu + tesseract.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from ..tools import find_tool, tool_env
+from .base import Extractor
+
+_ANNOTATION_RES = [
+    (re.compile(r'\(\s*title\s+"([^"]*)"\s*\)', re.I), "title"),
+    (re.compile(r'\(\s*author\s+"([^"]*)"\s*\)', re.I), "author"),
+    (re.compile(r"<title[^>]*>(.*?)</title>", re.I | re.S), "title"),
+    (re.compile(r"<author[^>]*>(.*?)</author>", re.I | re.S), "author"),
+]
+
+
+def _chunks(data: bytes, pos: int, end: int):
+    """Обойти чанки IFF: id(4) + длина(4, BE) + данные (с паддингом до чётности)."""
+    while pos + 8 <= end:
+        cid = data[pos:pos + 4]
+        length = int.from_bytes(data[pos + 4:pos + 8], "big")
+        body_start = pos + 8
+        body_end = body_start + length
+        if length < 0 or body_end > end:
+            return
+        yield cid, data[body_start:body_end]
+        pos = body_end + (length & 1)
+
+
+def find_annotations(data: bytes) -> dict[str, str]:
+    """Найти первый чанк ANTa и вытащить из него title/author."""
+
+    def walk(buf: bytes, pos: int, end: int) -> dict[str, str]:
+        for cid, body in _chunks(buf, pos, end):
+            if cid == b"FORM" and len(body) >= 4:
+                found = walk(body, 4, len(body))     # вложенные чанки формы
+                if found:
+                    return found
+            elif cid == b"ANTa":
+                text = body.decode("utf-8", "replace")
+                result: dict[str, str] = {}
+                for rx, key in _ANNOTATION_RES:
+                    m = rx.search(text)
+                    if m and not result.get(key):
+                        result[key] = re.sub(r"<[^>]+>", "", m.group(1)).strip()
+                if result:
+                    return result
+        return {}
+
+    start = 4 if data[:4] == b"AT&T" else 0
+    return walk(data, start, len(data))
+
+
+def _run(cmd: list[str], timeout: int = 120) -> str:
+    try:
+        res = subprocess.run(cmd, capture_output=True, timeout=timeout,
+                             check=False, env=tool_env(cmd[0] if cmd else None))
+    except (subprocess.TimeoutExpired, OSError):
+        return ""
+    return res.stdout.decode("utf-8", errors="replace")
+
+
+def djvulibre_text(path: Path, max_pages: int = 3) -> str:
+    """Текст первых страниц через djvutxt (djvulibre); "" если утилиты нет.
+
+    Разделитель страниц — form feed (\f).
+    """
+    exe = find_tool("djvutxt")
+    if not exe:
+        return ""
+    out = _run([exe, str(path)])
+    if not out.strip():
+        return ""
+    pages = out.split("\f")
+    return "\n".join(pages[:max_pages])
+
+
+class DjvuExtractor(Extractor):
+    extensions = (".djvu",)
+    ocr_capable = True          # рендер страниц через ddjvu + tesseract
+
+    def read_metadata(self, path: Path) -> tuple[str, str, str]:
+        try:
+            with open(path, "rb") as fh:
+                data = fh.read(4_000_000)
+        except OSError:
+            return "", "", ""
+        found = find_annotations(data)
+        return found.get("title", ""), found.get("author", ""), ""
+
+    def read_text(self, path: Path, max_pages: int = 3) -> str:
+        return djvulibre_text(path, max_pages=max_pages)

titlemark/extractors/docx.py

@@ -0,0 +1,63 @@
+"""Экстрактор DOCX: docProps/core.xml + первые абзацы word/document.xml."""
+
+from __future__ import annotations
+
+import re
+import zipfile
+from pathlib import Path
+from xml.etree import ElementTree
+
+from .base import Extractor
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_WT_RE = re.compile(r"<w:t[^>]*>(.*?)</w:t>", re.S)
+
+
+def _local(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1].lower()
+
+
+class DocxExtractor(Extractor):
+    extensions = (".docx",)
+
+    def read_metadata(self, path: Path) -> tuple[str, str, str]:
+        try:
+            with zipfile.ZipFile(path) as zf:
+                try:
+                    core = zf.read("docProps/core.xml")
+                except KeyError:
+                    return "", "", ""
+        except (zipfile.BadZipFile, OSError):
+            return "", "", ""
+
+        try:
+            root = ElementTree.fromstring(core)
+        except ElementTree.ParseError:
+            return "", "", ""
+
+        title = author = year = ""
+        for elem in root.iter():
+            name = _local(elem.tag)
+            text = (elem.text or "").strip()
+            if not text:
+                continue
+            if name == "title" and not title:
+                title = text
+            elif name == "creator" and not author:
+                author = text
+            elif name == "created":
+                m = re.search(r"\b(19|20)\d{2}\b", text)
+                if m:
+                    year = m.group(0)
+        return title, author, year
+
+    def read_text(self, path: Path, max_pages: int = 3) -> str:
+        try:
+            with zipfile.ZipFile(path) as zf:
+                doc = zf.read("word/document.xml").decode("utf-8", "replace")
+        except (zipfile.BadZipFile, KeyError, OSError):
+            return ""
+        parts = _WT_RE.findall(doc)
+        if parts:
+            return " ".join(_TAG_RE.sub("", p) for p in parts[:200])
+        return _TAG_RE.sub(" ", doc[:20000])

titlemark/extractors/epub.py

@@ -0,0 +1,63 @@
+"""Экстрактор EPUB: метаданные из package document (.opf)."""
+
+from __future__ import annotations
+
+import re
+import zipfile
+from pathlib import Path
+
+from .base import Extractor
+
+_DC_RE = {
+    "title": re.compile(r"<dc:title[^>]*>(.*?)</dc:title>", re.S | re.I),
+    "creator": re.compile(r"<dc:creator[^>]*>(.*?)</dc:creator>", re.S | re.I),
+    "date": re.compile(r"<dc:date[^>]*>(.*?)</dc:date>", re.S | re.I),
+}
+
+
+def _strip_tags(text: str) -> str:
+    return re.sub(r"<[^>]+>", "", text).strip()
+
+
+def _opf_path(zf: zipfile.ZipFile) -> str | None:
+    # 1) правильный путь через container.xml
+    try:
+        container = zf.read("META-INF/container.xml").decode("utf-8", "replace")
+        m = re.search(r'full-path="([^"]+)"', container)
+        if m:
+            return m.group(1)
+    except KeyError:
+        pass
+    # 2) найти первый .opf
+    for name in zf.namelist():
+        if name.lower().endswith(".opf"):
+            return name
+    return None
+
+
+class EpubExtractor(Extractor):
+    extensions = (".epub",)
+
+    def read_metadata(self, path: Path) -> tuple[str, str, str]:
+        try:
+            with zipfile.ZipFile(path) as zf:
+                opf = _opf_path(zf)
+                if not opf:
+                    return "", "", ""
+                data = zf.read(opf).decode("utf-8", "replace")
+        except (zipfile.BadZipFile, OSError):
+            return "", "", ""
+
+        def first(key: str) -> str:
+            m = _DC_RE[key].search(data)
+            return _strip_tags(m.group(1)) if m else ""
+
+        year = ""
+        m = re.search(r"\b(19|20)\d{2}\b", first("date"))
+        if m:
+            year = m.group(0)
+        return first("title"), first("creator"), year
+
+    def read_text(self, path: Path, max_pages: int = 3) -> str:
+        # метаданных EPUB почти всегда достаточно; текст не извлекаем
+        return ""

titlemark/extractors/fb2.py

@@ -0,0 +1,78 @@
+"""Экстрактор FB2: description/title-info/book-title и author."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from xml.etree import ElementTree
+
+from .base import Extractor
+
+
+def _local(tag: str) -> str:
+    """Тег без пространства имён (FB2 может использовать xmlns)."""
+    return tag.rsplit("}", 1)[-1].lower()
+
+
+def _text_of(elem) -> str:
+    return "".join(elem.itertext()).strip()
+
+
+class Fb2Extractor(Extractor):
+    extensions = (".fb2",)
+
+    def read_metadata(self, path: Path) -> tuple[str, str, str]:
+        try:
+            tree = ElementTree.parse(path)
+        except (ElementTree.ParseError, OSError):
+            return "", "", ""
+
+        title = author = year = ""
+        book_title_info = None
+
+        for elem in tree.iter():
+            name = _local(elem.tag)
+            if name == "title-info" and book_title_info is None:
+                book_title_info = elem
+
+        if book_title_info is not None:
+            for child in book_title_info:
+                cname = _local(child.tag)
+                if cname == "book-title":
+                    title = _text_of(child)
+                elif cname == "author":
+                    author = self._author_name(child)
+                elif cname == "date":
+                    m = re.search(r"\b(19|20)\d{2}\b", _text_of(child))
+                    if m:
+                        year = m.group(0)
+
+        if not title:
+            for elem in tree.iter():
+                if _local(elem.tag) == "book-title":
+                    title = _text_of(elem)
+                    break
+        return title, author, year
+
+    @staticmethod
+    def _author_name(author_elem) -> str:
+        parts: dict[str, str] = {}
+        for child in author_elem:
+            parts[_local(child.tag)] = _text_of(child)
+        first = parts.get("first-name", "")
+        middle = parts.get("middle-name", "")
+        last = parts.get("last-name", "")
+        nick = parts.get("nickname", "")
+
+        # инициалы: «Ю» + «А» + «Штюрмер» → «Штюрмер Ю. А.»
+        if first and len(first) <= 2 and last:
+            initials = first if first.endswith(".") else first + "."
+            if middle:
+                initials += " " + (middle if middle.endswith(".") else middle + ".")
+            return f"{last} {initials}".strip()
+
+        name = " ".join(p for p in (first, middle, last) if p).strip()
+        return name or nick
+
+    def read_text(self, path: Path, max_pages: int = 3) -> str:
+        return ""

titlemark/extractors/mobi.py

@@ -0,0 +1,99 @@
+"""Экстрактор MOBI: разбор PalmDB + EXTH-заголовков (без внешних библиотек)."""
+
+from __future__ import annotations
+
+import re
+import struct
+from pathlib import Path
+
+from .base import Extractor
+
+# типы EXTH-записей, которые нам нужны
+_EXTH_AUTHOR = 100
+_EXTH_PUBLISHED = 106
+_EXTH_TITLE_UPDATED = 503
+
+
+def _u2(data: bytes, off: int) -> int:
+    return struct.unpack_from(">H", data, off)[0]
+
+
+def _u4(data: bytes, off: int) -> int:
+    return struct.unpack_from(">I", data, off)[0]
+
+
+def _decode(raw: bytes, encoding: int) -> str:
+    enc = "utf-8" if encoding == 65001 else "cp1252"
+    try:
+        return raw.decode(enc)
+    except UnicodeDecodeError:
+        return raw.decode("cp1251", errors="replace")
+
+
+def parse_mobi(data: bytes) -> tuple[str, str, str]:
+    """Вернуть (title, author, year) из байтов MOBI-файла."""
+    if len(data) < 0x50 or b"MOBI" not in data[:0x200]:
+        return "", "", ""
+
+    num_records = _u2(data, 0x4C)
+    if num_records == 0 or len(data) < 0x4E + 8:
+        return "", "", ""
+    rec0_off = _u4(data, 0x4E)
+    if rec0_off >= len(data):
+        return "", "", ""
+    rec0 = data[rec0_off:]
+
+    if len(rec0) < 0x5C or rec0[0x10:0x14] != b"MOBI":
+        return "", "", ""
+    encoding = _u4(rec0, 0x1C)
+
+    # полное название книги хранится в самом MOBI-заголовке
+    title = ""
+    fullname_off = _u4(rec0, 0x54)
+    fullname_len = _u4(rec0, 0x58)
+    if fullname_len and fullname_off + fullname_len <= len(rec0):
+        title = _decode(rec0[fullname_off:fullname_off + fullname_len], encoding).strip()
+
+    author = year = ""
+    exth_flags = _u4(rec0, 0x80) if len(rec0) >= 0x84 else 0
+    if exth_flags & 0x40:
+        header_len = _u4(rec0, 0x14)
+        exth_off = 0x10 + header_len
+        if rec0[exth_off:exth_off + 4] == b"EXTH":
+            count = _u4(rec0, exth_off + 8)
+            pos = exth_off + 12
+            for _ in range(count):
+                if pos + 8 > len(rec0):
+                    break
+                etype = _u4(rec0, pos)
+                elen = _u4(rec0, pos + 4)
+                if elen < 8 or pos + elen > len(rec0):
+                    break
+                value = _decode(rec0[pos + 8:pos + elen], encoding).strip("\x00").strip()
+                if etype == _EXTH_TITLE_UPDATED and value:
+                    title = value
+                elif etype == _EXTH_AUTHOR and value:
+                    author = value
+                elif etype == _EXTH_PUBLISHED and value:
+                    m = re.search(r"\b(19|20)\d{2}\b", value)
+                    if m:
+                        year = m.group(0)
+                pos += elen
+
+    return title, author, year
+
+
+class MobiExtractor(Extractor):
+    extensions = (".mobi", ".azw", ".prc")
+
+    def read_metadata(self, path: Path) -> tuple[str, str, str]:
+        try:
+            # заголовки лежат в первых килобайтах; читаем с запасом
+            with open(path, "rb") as fh:
+                data = fh.read(2_000_000)
+        except OSError:
+            return "", "", ""
+        return parse_mobi(data)
+
+    def read_text(self, path: Path, max_pages: int = 3) -> str:
+        return ""

titlemark/extractors/pdf.py

@@ -0,0 +1,74 @@
+"""Экстрактор PDF: poppler (pdfinfo/pdftotext) + OCR как запасной путь."""
+
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+
+from ..tools import find_tool, run_tool
+from .base import Extractor
+
+_PDFINFO_RE = re.compile(r"^([^:]+):\s*(.*)$")
+
+
+@lru_cache(maxsize=1)
+def _tools() -> dict[str, str | None]:
+    return {
+        "pdfinfo": find_tool("pdfinfo"),
+        "pdftotext": find_tool("pdftotext"),
+        "pdftoppm": find_tool("pdftoppm"),
+    }
+
+
+def _run(cmd: list[str], timeout: int = 60) -> str:
+    if not cmd or not cmd[0]:
+        return ""
+    return run_tool(cmd[0], cmd[1:], timeout=timeout)
+
+
+def pdfinfo_fields(path: Path) -> dict[str, str]:
+    """Свойства PDF в виде словаря {'Title': ..., 'Author': ...}."""
+    exe = _tools()["pdfinfo"]
+    if not exe:
+        return {}
+    out = _run([exe, str(path)])
+    fields: dict[str, str] = {}
+    for line in out.splitlines():
+        m = _PDFINFO_RE.match(line)
+        if m:
+            fields[m.group(1).strip()] = m.group(2).strip()
+    return fields
+
+
+def _year_from_pdfinfo(fields: dict[str, str]) -> str:
+    for key in ("CreationDate", "ModDate"):
+        m = re.search(r"(19|20)\d{2}", fields.get(key, ""))
+        if m:
+            return m.group(0)
+    return ""
+
+
+class PdfExtractor(Extractor):
+    extensions = (".pdf",)
+    ocr_capable = True
+
+    def read_metadata(self, path: Path) -> tuple[str, str, str]:
+        fields = pdfinfo_fields(path)
+        return (
+            fields.get("Title", ""),
+            fields.get("Author", ""),
+            _year_from_pdfinfo(fields),
+        )
+
+    def read_text(self, path: Path, max_pages: int = 3) -> str:
+        exe = _tools()["pdftotext"]
+        if not exe:
+            return ""
+        out = _run(
+            [exe, "-f", "1", "-l", str(max_pages), "-layout", "-q", str(path), "-"],
+            timeout=90,
+        )
+        # убрать символы, полученные из-за неверной кодировки ToUnicode,
+        # они всё равно не помогут в поиске заголовка
+        return out.replace("\x0c", "\n")

titlemark/models.py

@@ -0,0 +1,48 @@
+"""Модели данных проекта titlemark."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+
+class Source(str, Enum):
+    """Откуда получены данные о документе."""
+
+    METADATA = "metadata"      # свойства/метаданные файла
+    TEXT = "text"              # текстовый слой документа
+    OCR = "ocr"                # OCR отсканированных страниц
+    AI = "ai"                  # vision-LLM по обложке (--ai)
+    FILENAME = "filename"      # разбор текущего имени файла
+    NONE = "none"              # ничего не найдено
+
+
+class TextQuality(str, Enum):
+    """Качество извлечённого текста."""
+
+    GOOD = "good"
+    GARBAGE = "garbage"        # кракозябры из-за нестандартной кодировки шрифтов
+    EMPTY = "empty"            # текстового слоя нет (скан)
+
+
+@dataclass
+class DocumentInfo:
+    """Результат извлечения сведений о документе."""
+
+    path: Path
+    format: str = ""
+    title: str = ""
+    author: str = ""
+    year: str = ""
+    title_source: Source = Source.NONE
+    author_source: Source = Source.NONE
+    warnings: list[str] = field(default_factory=list)
+    # отладочная информация для --verbose
+    text_snippet: str = ""
+    title_candidates: list[tuple[str, float]] = field(default_factory=list)
+
+    @property
+    def resolved(self) -> bool:
+        """Есть ли хоть какой-то полезный результат."""
+        return bool(self.title or self.author)

titlemark/names.py

@@ -0,0 +1,91 @@
+"""Распознавание имён людей в строках титульных страниц.
+
+Заголовок «DARK MATTER» и подпись автора «BLAKE CROUCH» на обложке
+выглядят одинаково (2 слова ЗАГЛАВНЫМИ). Разделяем их по словарю
+распространённых имён: если одно из слов строки — известное имя,
+строка скорее подпись автора.
+"""
+
+from __future__ import annotations
+
+import re
+
+_RU_FIRST_NAMES = frozenset("""
+александр алексей алина алла анастасия андрей анна антон аркадий артур
+борис богдан вадим валерий валерия варвара василий вера вероника виктор
+виктория виталий владимир владислав галина геннадий георгий григорий дарья
+денис дмитрий ева евгений евгения егор екатерина елена елизавета жанна
+зинаида игорь иван илья инна ирина кирилл константин ксения лариса лев
+леонид лидия любовь людмила маргарита марина мария михаил
+надежда наталья никита николай нина оксана олег ольга павел пётр петр
+полина роман руслан светлана семён сеня сергей софия софья станислав
+степан тамара тарас татьяна тимур тимофей ульяна фёдор федор филипп
+эдуард юлия юрий яков яна ярослав джоан джоанна джордж
+# транслитерации частых английских имён (книги в переводе)
+уильям джон джеймс роберт майкл дэвид эдвард томас ричард чарльз
+дэниел дэниэл мэтью мартин брайан брюс винсент гарри герберт деннис
+джеральд джозеф джонатан дуглас итан кеннет кевин лоуренс леонард
+малкольм николас марк оливер патрик питер рональд стэнли стивен
+теренс теодор франклин фредерик гарольд эндрю альберт арчибальд гас
+элизабет дженнифер джессика кэтрин кэти мэри сара джейн лора эмма
+линда маргарет моника нэнси патриция ребекка розмари сьюзан тереза
+алиса аманда барбара бренда дебора диана дорис джудит кэрол
+натали хелен хизер шерон ширли дебби
+""".split())
+
+_EN_FIRST_NAMES = frozenset("""
+aaron adam alan albert alex alexander alice amanda amy andrew angela
+anna anthony arthur audrey barbara barry benjamin bernard betty beverly
+blake brandon brenda brian bruce bryan carol carter catherine cathy
+charles charlotte cheryl chris christian christina christine christopher
+cindy claire clarence clifford colin colleen connor cody craig cynthia
+dale daniel danielle darren david dean deborah debra dennis derek diana
+diane donald donna doris dorothy douglas dylan earl edgar edith edward
+edwin eleanor elena elizabeth ellie ellen emily emma eric erica ernest
+esther eugene evan evelyn fiona florence frances frank franklin
+frederick gabriel gary george gerald gina gilbert glenn grace gregory
+hannah harold harriet harry harvey heather helen henry herbert howard
+hugh ian irene isaac isabel ivan jack jacob james jane janet janice
+jared jason jay jean jeffrey jennifer jeremy jerry jessica jill joan
+joanne joe joel john johnny jonathan jordan joseph joshua joyce judith
+julia julian julie justin karen karl katherine kathleen kathryn kathy
+keith kelly kenneth kevin kimberly kurt kyle larry laura lauren lawrence
+leonard leslie lewis liam linda lisa lloyd logan lois louis louise lucas
+luke lydia lynn madison malcolm marcus margaret maria marie marilyn mark
+martha martin mary matthew maureen max megan melanie melissa michael
+michelle mildred monica natalie nathan neil nelson nicholas nicole nigel
+nina nora norman oliver oscar owen pamela patricia patrick paul paula
+pedro peggy peter philip phoebe phyllis quentin rachel ralph randall
+raymond rebecca regina richard rita robert roberta robin rodney roger
+roland ronald rosa rose ross roy russell ruth ryan sabrina samantha
+samuel sandra sarah scott sean seth sharon sheila shirley sidney simon
+sophia spencer stanley stephanie stephen steven stuart susan sylvia
+tamara tanya teresa thomas timothy tina todd travis trevor tyler valerie
+vanessa vera vernon veronica victor victoria vincent virginia vivian
+walter wanda warren wayne wendy wesley william willie zachary zoe
+""".split())
+
+_FIRST_NAMES = _RU_FIRST_NAMES | _EN_FIRST_NAMES
+
+_WORDS_RE = re.compile(r"[^\s,]+")
+
+
+def is_person_name(text: str) -> bool:
+    """Похожа ли строка на имя человека: «АРТУР ДУМЧЕВ», «by Jane Smith».
+
+    Правила: 2–3 слова, среди них есть известное имя на первой или
+    последней позиции, остальные слова — инициалы или с заглавной буквы.
+    """
+    t = text.strip().strip(",;:-–—")
+    words = [w.strip(".,'’\"()") for w in _WORDS_RE.findall(t)]
+    if not (2 <= len(words) <= 3) or any(not w for w in words):
+        return False
+
+    known_positions = [i for i, w in enumerate(words) if w.lower() in _FIRST_NAMES]
+    if not known_positions:
+        return False
+    # имя должно быть первым или последним словом («ЧТО БУДЕТ» — не имя)
+    if not any(i in (0, len(words) - 1) for i in known_positions):
+        return False
+    # остальные слова: инициалы («В.») или слова с заглавной буквы
+    return all(len(w) <= 2 or w[0].isupper() for w in words)