msdoc2docx 0.7.0__py3-none-any.whl

doc2docx/msdoc/__init__.py

@@ -0,0 +1,24 @@
+from .document_properties import WordDocumentSettings, read_document_settings
+from .fib import FileInformationBlock
+from .fonts import read_font_table
+from .formatting import FormattingMap, read_formatting
+from .headers import HeaderFooterCollection, read_header_footer_stories
+from .pieces import Piece, PieceTable, read_piece_table
+from .sections import read_sections
+from .styles import read_style_sheet
+
+__all__ = [
+    "FileInformationBlock",
+    "FormattingMap",
+    "HeaderFooterCollection",
+    "Piece",
+    "PieceTable",
+    "WordDocumentSettings",
+    "read_document_settings",
+    "read_font_table",
+    "read_formatting",
+    "read_header_footer_stories",
+    "read_piece_table",
+    "read_sections",
+    "read_style_sheet",
+]

doc2docx/msdoc/document_properties.py

@@ -0,0 +1,31 @@
+"""Minimal parsing of document-wide settings from the MS-DOC DOP."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import struct
+
+from ..errors import InvalidWordDocument
+
+
+@dataclass(slots=True, frozen=True)
+class WordDocumentSettings:
+    even_and_odd_headers: bool = False
+
+
+def read_document_settings(
+    table_stream: bytes,
+    *,
+    offset: int,
+    size: int,
+) -> WordDocumentSettings:
+    if size == 0:
+        return WordDocumentSettings()
+    if offset < 0 or size < 0 or offset > len(table_stream) - size:
+        raise InvalidWordDocument(
+            f"DOP range [{offset}, {offset + size}) exceeds Table stream"
+        )
+    if size < 2:
+        raise InvalidWordDocument("DOP is truncated before DopBase flags")
+    flags = struct.unpack_from("<H", table_stream, offset)[0]
+    return WordDocumentSettings(even_and_odd_headers=bool(flags & 0x0001))

doc2docx/msdoc/fib.py

@@ -0,0 +1,246 @@
+"""File Information Block parsing for Word 97-2003 binary documents."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..binary import BinaryReader
+from ..errors import BinaryBoundsError, InvalidWordDocument
+
+
+FIB_IDENT = 0xA5EC
+# FibRgFcLcb97 includes the deprecated fcPlcPad/lcbPlcPad pair after
+# fcPlcfSed/lcbPlcfSed. Therefore fcClx/lcbClx is pair 33 (zero-based).
+FCLCB97_STSHF_INDEX = 1
+FCLCB97_PLCF_SED_INDEX = 6
+FCLCB97_PLCF_HDD_INDEX = 11
+FCLCB97_PLCF_BTE_CHPX_INDEX = 12
+FCLCB97_PLCF_BTE_PAPX_INDEX = 13
+FCLCB97_STTBF_FFN_INDEX = 15
+FCLCB97_DOP_INDEX = 31
+FCLCB97_CLX_INDEX = 33
+
+
+@dataclass(slots=True, frozen=True)
+class FibBase:
+    w_ident: int
+    n_fib: int
+    lid: int
+    flags: int
+    n_fib_back: int
+    l_key: int
+    environment: int
+    flags2: int
+
+    @property
+    def is_template(self) -> bool:
+        return bool(self.flags & 0x0001)
+
+    @property
+    def is_complex(self) -> bool:
+        return bool(self.flags & 0x0004)
+
+    @property
+    def has_pictures(self) -> bool:
+        return bool(self.flags & 0x0008)
+
+    @property
+    def is_encrypted(self) -> bool:
+        return bool(self.flags & 0x0100)
+
+    @property
+    def uses_1table(self) -> bool:
+        return bool(self.flags & 0x0200)
+
+    @property
+    def is_write_reserved(self) -> bool:
+        return bool(self.flags & 0x0800)
+
+    @property
+    def is_obfuscated(self) -> bool:
+        return bool(self.flags & 0x8000)
+
+    @property
+    def table_stream_name(self) -> str:
+        return "1Table" if self.uses_1table else "0Table"
+
+
+@dataclass(slots=True, frozen=True)
+class FcLcb:
+    fc: int
+    lcb: int
+
+
+@dataclass(slots=True, frozen=True)
+class FileInformationBlock:
+    base: FibBase
+    fib_rg_w: tuple[int, ...]
+    fib_rg_lw: tuple[int, ...]
+    fib_rg_fc_lcb: tuple[FcLcb, ...]
+    fib_rg_csw_new: tuple[int, ...]
+    fib_size: int
+
+    @property
+    def n_fib(self) -> int:
+        return self.fib_rg_csw_new[0] if self.fib_rg_csw_new else self.base.n_fib
+
+    @property
+    def ccp_text(self) -> int:
+        if len(self.fib_rg_lw) <= 3:
+            raise InvalidWordDocument("FIB does not contain FibRgLw97.ccpText")
+        return self.fib_rg_lw[3]
+
+    @property
+    def ccp_footnotes(self) -> int:
+        return self.fib_rg_lw[4] if len(self.fib_rg_lw) > 4 else 0
+
+    @property
+    def ccp_headers(self) -> int:
+        return self.fib_rg_lw[5] if len(self.fib_rg_lw) > 5 else 0
+
+    @property
+    def header_story_cp_start(self) -> int:
+        return self.ccp_text + self.ccp_footnotes
+
+    @property
+    def cb_mac(self) -> int:
+        if not self.fib_rg_lw:
+            raise InvalidWordDocument("FIB does not contain FibRgLw97.cbMac")
+        return self.fib_rg_lw[0]
+
+    @property
+    def secondary_story_character_counts(self) -> dict[str, int]:
+        names_and_indexes = (
+            ("footnotes", 4),
+            ("headers", 5),
+            ("comments", 7),
+            ("endnotes", 8),
+            ("textboxes", 9),
+            ("header_textboxes", 10),
+        )
+        return {
+            name: self.fib_rg_lw[index]
+            for name, index in names_and_indexes
+            if index < len(self.fib_rg_lw) and self.fib_rg_lw[index]
+        }
+
+    @property
+    def clx(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_CLX_INDEX:
+            raise InvalidWordDocument("FIB does not contain fcClx/lcbClx")
+        return self.fib_rg_fc_lcb[FCLCB97_CLX_INDEX]
+
+    @property
+    def stshf(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_STSHF_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_STSHF_INDEX]
+
+    @property
+    def plcf_sed(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_PLCF_SED_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_PLCF_SED_INDEX]
+
+    @property
+    def plcf_hdd(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_PLCF_HDD_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_PLCF_HDD_INDEX]
+
+    @property
+    def dop(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_DOP_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_DOP_INDEX]
+
+    @property
+    def sttbf_ffn(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_STTBF_FFN_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_STTBF_FFN_INDEX]
+
+    @property
+    def plcf_bte_chpx(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_PLCF_BTE_CHPX_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_PLCF_BTE_CHPX_INDEX]
+
+    @property
+    def plcf_bte_papx(self) -> FcLcb:
+        if len(self.fib_rg_fc_lcb) <= FCLCB97_PLCF_BTE_PAPX_INDEX:
+            return FcLcb(0, 0)
+        return self.fib_rg_fc_lcb[FCLCB97_PLCF_BTE_PAPX_INDEX]
+
+    @classmethod
+    def parse(cls, word_document_stream: bytes) -> "FileInformationBlock":
+        reader = BinaryReader(word_document_stream, label="WordDocument FIB")
+        try:
+            w_ident = reader.u16()
+            n_fib = reader.u16()
+            reader.skip(2)  # unused
+            lid = reader.u16()
+            reader.skip(2)  # pnNext
+            flags = reader.u16()
+            n_fib_back = reader.u16()
+            l_key = reader.u32()
+            environment = reader.u8()
+            flags2 = reader.u8()
+            reader.skip(12)  # reserved3 through reserved6
+
+            if w_ident != FIB_IDENT:
+                raise InvalidWordDocument(
+                    f"WordDocument FIB has wIdent 0x{w_ident:04X}; expected 0xA5EC"
+                )
+
+            csw = reader.u16()
+            fib_rg_w = tuple(reader.u16() for _ in range(csw))
+
+            cslw = reader.u16()
+            fib_rg_lw = tuple(reader.u32() for _ in range(cslw))
+
+            cb_rg_fc_lcb = reader.u16()
+            fib_rg_fc_lcb = tuple(
+                FcLcb(reader.u32(), reader.u32()) for _ in range(cb_rg_fc_lcb)
+            )
+            if reader.remaining >= 2:
+                csw_new = reader.u16()
+                fib_rg_csw_new = tuple(reader.u16() for _ in range(csw_new))
+            else:
+                fib_rg_csw_new = ()
+        except BinaryBoundsError as exc:
+            raise InvalidWordDocument(f"truncated or invalid FIB: {exc}") from exc
+
+        if csw < 14:
+            raise InvalidWordDocument(
+                f"FIB FibRgW has {csw} words; Word 97 layout requires at least 14"
+            )
+        if cslw < 11:
+            raise InvalidWordDocument(
+                f"FIB FibRgLw has {cslw} values; expected at least 11"
+            )
+        if cb_rg_fc_lcb <= FCLCB97_CLX_INDEX:
+            raise InvalidWordDocument(
+                f"FIB has {cb_rg_fc_lcb} fc/lcb pairs and no CLX entry"
+            )
+        ccp_text = fib_rg_lw[3]
+        if ccp_text >= 0x7FFFFFFF:
+            raise InvalidWordDocument(f"invalid main-story character count {ccp_text}")
+
+        return cls(
+            base=FibBase(
+                w_ident,
+                n_fib,
+                lid,
+                flags,
+                n_fib_back,
+                l_key,
+                environment,
+                flags2,
+            ),
+            fib_rg_w=fib_rg_w,
+            fib_rg_lw=fib_rg_lw,
+            fib_rg_fc_lcb=fib_rg_fc_lcb,
+            fib_rg_csw_new=fib_rg_csw_new,
+            fib_size=reader.position,
+        )

doc2docx/msdoc/fonts.py

@@ -0,0 +1,132 @@
+"""MS-DOC SttbfFfn and FFN font-table parsing."""
+
+from __future__ import annotations
+
+import struct
+
+from ..errors import InvalidWordDocument
+from ..model import FontDefinition
+
+
+_FONT_FAMILIES = {
+    0: "auto",
+    1: "roman",
+    2: "swiss",
+    3: "modern",
+    4: "script",
+    5: "decorative",
+}
+
+_FONT_PITCHES = {
+    0: "default",
+    1: "fixed",
+    2: "variable",
+}
+
+
+def _decode_xsz_ffn(data: bytes, *, label: str) -> tuple[str, ...]:
+    if len(data) % 2:
+        raise InvalidWordDocument(f"{label} font names have an odd byte count")
+    code_units = struct.unpack(f"<{len(data) // 2}H", data)
+    names: list[str] = []
+    start = 0
+    for index, value in enumerate(code_units):
+        if value != 0:
+            continue
+        raw_name = data[start * 2 : index * 2]
+        names.append(raw_name.decode("utf-16le", errors="replace"))
+        start = index + 1
+    if start != len(code_units):
+        raise InvalidWordDocument(f"{label} font name is not null-terminated")
+    return tuple(names)
+
+
+def _parse_ffn(index: int, data: bytes) -> FontDefinition:
+    # ffid(1), wWeight(2), chs(1), ixchSzAlt(1), PANOSE(10), FONTSIGNATURE(24)
+    if len(data) < 41:
+        raise InvalidWordDocument(
+            f"SttbfFfn font {index} has {len(data)} bytes; expected at least 41"
+        )
+    ffid = data[0]
+    weight = struct.unpack_from("<h", data, 1)[0]
+    charset = data[3]
+    alternate_index = data[4]
+    panose = data[5:15]
+    signature = data[15:39]
+    names = _decode_xsz_ffn(data[39:], label=f"SttbfFfn font {index}")
+    if not names or not names[0]:
+        raise InvalidWordDocument(f"SttbfFfn font {index} has no primary name")
+
+    alternate_name: str | None = None
+    if alternate_index:
+        # ixchSzAlt is an index in UTF-16 code units from xszFfn. Real-world
+        # files normally place the alternate name immediately after the first
+        # terminator; prefer the indexed value but tolerate that common layout.
+        name_data = data[39:]
+        byte_offset = alternate_index * 2
+        if byte_offset < len(name_data):
+            tail = _decode_xsz_ffn(
+                name_data[byte_offset:],
+                label=f"SttbfFfn font {index} alternate name",
+            )
+            alternate_name = tail[0] if tail and tail[0] else None
+        elif len(names) > 1:
+            alternate_name = names[1] or None
+    elif len(names) > 1:
+        alternate_name = names[1] or None
+
+    return FontDefinition(
+        index=index,
+        name=names[0],
+        alternate_name=alternate_name,
+        charset=charset,
+        family=_FONT_FAMILIES.get((ffid >> 4) & 0x07),
+        pitch=_FONT_PITCHES.get(ffid & 0x03),
+        weight=weight if weight > 0 else None,
+        panose=panose,
+        signature=signature,
+    )
+
+
+def read_font_table(
+    table_stream: bytes,
+    *,
+    offset: int,
+    size: int,
+) -> tuple[FontDefinition, ...]:
+    """Parse the non-extended STTB used by SttbfFfn."""
+
+    if size == 0:
+        return ()
+    if offset < 0 or size < 0 or offset > len(table_stream) - size:
+        raise InvalidWordDocument(
+            f"SttbfFfn range [{offset}, {offset + size}) exceeds Table stream"
+        )
+    data = table_stream[offset : offset + size]
+    if len(data) < 4:
+        raise InvalidWordDocument("SttbfFfn is truncated")
+    count, extra_size = struct.unpack_from("<HH", data)
+    if count == 0xFFFF:
+        raise InvalidWordDocument("extended SttbfFfn layout is not valid for MS-DOC")
+    if extra_size:
+        raise InvalidWordDocument(
+            f"SttbfFfn has unsupported cbExtra value {extra_size}"
+        )
+
+    fonts: list[FontDefinition] = []
+    position = 4
+    for index in range(count):
+        if position >= len(data):
+            raise InvalidWordDocument(f"SttbfFfn is truncated before font {index}")
+        byte_count = data[position]
+        position += 1
+        end = position + byte_count
+        if end > len(data):
+            raise InvalidWordDocument(f"SttbfFfn font {index} exceeds the table")
+        fonts.append(_parse_ffn(index, data[position:end]))
+        position = end
+    if position != len(data) and any(data[position:]):
+        raise InvalidWordDocument(
+            f"SttbfFfn has {len(data) - position} unexpected trailing bytes"
+        )
+    return tuple(fonts)