agent-folder-workspace 0.1.0__py3-none-any.whl

agent_folder_workspace/adapters/odf.py

@@ -0,0 +1,636 @@
+"""Safe, direct ODF ZIP/XML hierarchy without a LibreOffice runtime."""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import Any, cast
+from zipfile import BadZipFile, ZipFile, ZipInfo
+
+from defusedxml import ElementTree as SafeElementTree  # type: ignore[import-untyped]
+from defusedxml.common import DefusedXmlException  # type: ignore[import-untyped]
+
+from agent_folder_workspace.adapters.base import BaseAdapter, ReadResult, VirtualNodeSpec
+from agent_folder_workspace.config import WorkspaceConfig
+from agent_folder_workspace.errors import InputValidationError, ResourceLimitError
+from agent_folder_workspace.models import NodeKind, NodeV1
+
+_OFFICE = "urn:oasis:names:tc:opendocument:xmlns:office:1.0"
+_TEXT = "urn:oasis:names:tc:opendocument:xmlns:text:1.0"
+_TABLE = "urn:oasis:names:tc:opendocument:xmlns:table:1.0"
+_DRAW = "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"
+_MANIFEST = "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
+_BLOCK_SIZE = 1_000
+
+
+class OdfAdapter(BaseAdapter):
+    """Expose ODT, ODS, and ODP semantics alongside every package part."""
+
+    def __init__(self, family: str) -> None:
+        if family not in {"text", "spreadsheet", "presentation"}:
+            raise ValueError(f"unsupported ODF family: {family}")
+        self.family = family
+
+    def _infos(self, source: Path, config: WorkspaceConfig) -> list[ZipInfo]:
+        try:
+            with ZipFile(source) as package:
+                infos = package.infolist()
+        except (BadZipFile, OSError) as error:
+            raise InputValidationError(f"invalid ODF package: {source.name}") from error
+        if len(infos) > config.max_zip_entries:
+            raise ResourceLimitError(f"ODF package exceeds {config.max_zip_entries} entries")
+        if sum(info.file_size for info in infos) > config.max_zip_uncompressed_bytes:
+            raise ResourceLimitError(
+                f"ODF package exceeds {config.max_zip_uncompressed_bytes} uncompressed bytes"
+            )
+        seen: set[str] = set()
+        for info in infos:
+            name = info.filename
+            path = PurePosixPath(name)
+            if name.startswith("/") or "\\" in name or ".." in path.parts:
+                raise InputValidationError(f"unsafe ODF package part name: {name}")
+            if name in seen:
+                raise InputValidationError(f"duplicate ODF package part: {name}")
+            seen.add(name)
+            if info.flag_bits & 0x1:
+                raise InputValidationError("encrypted ODF package parts are not supported")
+            if info.compress_size and info.file_size / info.compress_size > 1_000:
+                raise ResourceLimitError("ODF package contains a compression bomb candidate")
+        manifest = next((info for info in infos if info.filename == "META-INF/manifest.xml"), None)
+        if manifest is not None and not manifest.is_dir():
+            if manifest.file_size > config.max_xml_bytes:
+                raise ResourceLimitError("ODF manifest exceeds the XML size limit")
+            try:
+                with ZipFile(source) as package:
+                    manifest_root = SafeElementTree.fromstring(package.read(manifest))
+            except (
+                BadZipFile,
+                OSError,
+                RuntimeError,
+                SafeElementTree.ParseError,
+                DefusedXmlException,
+                ValueError,
+            ) as error:
+                raise InputValidationError("invalid ODF package manifest") from error
+            if manifest_root.find(f".//{{{_MANIFEST}}}encryption-data") is not None:
+                raise InputValidationError("encrypted ODF content requires a credential")
+        return infos
+
+    def _info(self, source: Path, name: str, config: WorkspaceConfig) -> ZipInfo:
+        info = next(
+            (candidate for candidate in self._infos(source, config) if candidate.filename == name),
+            None,
+        )
+        if info is None or info.is_dir():
+            raise InputValidationError(f"ODF part not found: {name}")
+        return info
+
+    def _part(
+        self,
+        source: Path,
+        name: str,
+        config: WorkspaceConfig,
+        *,
+        maximum: int | None = None,
+    ) -> bytes:
+        info = self._info(source, name, config)
+        if maximum is not None and info.file_size > maximum:
+            raise ResourceLimitError(f"ODF part {name} exceeds {maximum} bytes")
+        try:
+            with ZipFile(source) as package:
+                return package.read(info)
+        except (BadZipFile, OSError, RuntimeError) as error:
+            raise InputValidationError(f"unable to read ODF part: {name}") from error
+
+    def _xml(self, source: Path, name: str, config: WorkspaceConfig) -> Any:
+        payload = self._part(source, name, config, maximum=config.max_xml_bytes)
+        try:
+            return SafeElementTree.fromstring(payload)
+        except (SafeElementTree.ParseError, DefusedXmlException, ValueError) as error:
+            raise InputValidationError(f"invalid ODF XML part: {name}") from error
+
+    def _names(self, source: Path, config: WorkspaceConfig) -> list[str]:
+        return sorted(info.filename for info in self._infos(source, config) if not info.is_dir())
+
+    @staticmethod
+    def _local_name(tag: str) -> str:
+        return tag.rsplit("}", 1)[-1]
+
+    def _element_text(self, element: Any, config: WorkspaceConfig) -> str:
+        pieces: list[str] = []
+        byte_count = 0
+        visited = 0
+        stack: list[tuple[str, Any]] = [("element", element)]
+        while stack:
+            operation, current = stack.pop()
+            if operation == "text":
+                piece = str(current)
+                pieces.append(piece)
+                byte_count += len(piece.encode("utf-8"))
+                if byte_count > config.max_content_cache_bytes:
+                    raise ResourceLimitError("ODF text exceeds the configured content limit")
+                continue
+            visited += 1
+            if visited > config.max_index_nodes_per_file:
+                raise ResourceLimitError("ODF XML exceeds the structural element limit")
+            child_operations: list[tuple[str, Any]] = []
+            if current.text:
+                child_operations.append(("text", str(current.text)))
+            for child in current:
+                if child.tag == f"{{{_TEXT}}}s":
+                    repeated = self._repeat(
+                        child.attrib.get(f"{{{_TEXT}}}c", "1"), config, "spaces"
+                    )
+                    child_operations.append(("text", " " * repeated))
+                elif child.tag == f"{{{_TEXT}}}tab":
+                    child_operations.append(("text", "\t"))
+                elif child.tag == f"{{{_TEXT}}}line-break":
+                    child_operations.append(("text", "\n"))
+                else:
+                    child_operations.append(("element", child))
+                if child.tail:
+                    child_operations.append(("text", str(child.tail)))
+            stack.extend(reversed(child_operations))
+        return "".join(pieces)
+
+    @staticmethod
+    def _repeat(raw: str, config: WorkspaceConfig, label: str) -> int:
+        try:
+            value = int(raw)
+        except ValueError as error:
+            raise InputValidationError(f"invalid ODF {label} repetition") from error
+        if value < 1:
+            raise InputValidationError(f"invalid ODF {label} repetition")
+        if value > config.max_zip_entries:
+            raise ResourceLimitError(f"ODF {label} repetition exceeds structural limit")
+        return value
+
+    def _content_root(self, source: Path, config: WorkspaceConfig) -> Any:
+        return self._xml(source, "content.xml", config)
+
+    def _paragraph_elements(self, source: Path, config: WorkspaceConfig) -> list[Any]:
+        root = self._content_root(source, config)
+        body = root.find(f".//{{{_OFFICE}}}text")
+        if body is None:
+            raise InputValidationError("ODT document has no text body")
+        paragraphs: list[Any] = []
+        visited = 0
+        pending = list(reversed(list(body)))
+        while pending:
+            element = pending.pop()
+            visited += 1
+            if visited > config.max_index_nodes_per_file:
+                raise ResourceLimitError("ODF XML exceeds the structural element limit")
+            if element.tag == f"{{{_TABLE}}}table":
+                continue
+            if element.tag in {f"{{{_TEXT}}}h", f"{{{_TEXT}}}p"}:
+                paragraphs.append(element)
+                continue
+            pending.extend(reversed(list(element)))
+        return paragraphs
+
+    def _tables(self, source: Path, config: WorkspaceConfig) -> list[Any]:
+        return cast(list[Any], self._content_root(source, config).findall(f".//{{{_TABLE}}}table"))
+
+    def _sheets(self, source: Path, config: WorkspaceConfig) -> list[Any]:
+        return cast(list[Any], self._content_root(source, config).findall(f".//{{{_TABLE}}}table"))
+
+    def _slides(self, source: Path, config: WorkspaceConfig) -> list[Any]:
+        return cast(list[Any], self._content_root(source, config).findall(f".//{{{_DRAW}}}page"))
+
+    def _metadata(self, source: Path, config: WorkspaceConfig) -> dict[str, str]:
+        if "meta.xml" not in self._names(source, config):
+            return {}
+        root = self._xml(source, "meta.xml", config)
+        result: dict[str, str] = {}
+        for element in root.findall(f".//{{{_OFFICE}}}meta//*"):
+            text = self._element_text(element, config).strip()
+            if text and len(element) == 0:
+                result[self._local_name(str(element.tag))] = text
+        return result
+
+    def _root_categories(self, source: Path, config: WorkspaceConfig) -> list[VirtualNodeSpec]:
+        infos = {info.filename: info for info in self._infos(source, config) if not info.is_dir()}
+        labels = {
+            "text": ("metadata", "paragraphs", "tables", "package_parts"),
+            "spreadsheet": ("metadata", "sheets", "package_parts"),
+            "presentation": ("metadata", "slides", "package_parts"),
+        }[self.family]
+        counts = {
+            "metadata": 1,
+            "paragraphs": len(self._paragraph_elements(source, config))
+            if self.family == "text"
+            else 0,
+            "tables": len(self._tables(source, config)) if self.family == "text" else 0,
+            "sheets": len(self._sheets(source, config)) if self.family == "spreadsheet" else 0,
+            "slides": len(self._slides(source, config)) if self.family == "presentation" else 0,
+            "package_parts": len(infos),
+        }
+        semantic_labels = {"paragraphs", "tables", "sheets", "slides"}
+        result = []
+        for label in labels:
+            source_part = (
+                "meta.xml"
+                if label == "metadata" and "meta.xml" in infos
+                else "content.xml"
+                if label in semantic_labels
+                else None
+            )
+            result.append(
+                VirtualNodeSpec(
+                    name=label,
+                    kind=NodeKind.METADATA if label == "metadata" else NodeKind.CONTAINER,
+                    logical_path=f"/odf/{self.family}/{label}",
+                    child_count=counts[label] if label != "metadata" else 0,
+                    metadata={"odf_category": label},
+                    source_part=source_part,
+                    source_offset=0 if source_part is not None else None,
+                    source_length=(
+                        infos[source_part].file_size if source_part is not None else None
+                    ),
+                )
+            )
+        return result
+
+    def _package_part_specs(
+        self, node: NodeV1, source: Path, config: WorkspaceConfig
+    ) -> list[VirtualNodeSpec]:
+        infos = {info.filename: info for info in self._infos(source, config)}
+        return [
+            VirtualNodeSpec(
+                name=name,
+                kind=NodeKind.PACKAGE_PART,
+                logical_path=f"{node.logical_path}/{name}",
+                size=infos[name].file_size,
+                metadata={"binary_part": name, "odf_category": "package_parts"},
+                source_part=name,
+                source_offset=0,
+                source_length=infos[name].file_size,
+            )
+            for name in self._names(source, config)
+        ]
+
+    @staticmethod
+    def _block_specs(
+        logical_path: str,
+        label: str,
+        count: int,
+        block_type: str,
+        source_part: str | None = None,
+        source_length: int | None = None,
+        **metadata: Any,
+    ) -> list[VirtualNodeSpec]:
+        return [
+            VirtualNodeSpec(
+                name=f"{label} {start + 1}-{min(start + _BLOCK_SIZE, count)}",
+                kind=NodeKind.ROW_BLOCK,
+                logical_path=f"{logical_path}/{start}:{min(start + _BLOCK_SIZE, count)}",
+                metadata={
+                    "block_type": block_type,
+                    "start": start,
+                    "end": min(start + _BLOCK_SIZE, count),
+                    **metadata,
+                },
+                source_part=source_part,
+                source_offset=0 if source_part is not None else None,
+                source_length=source_length,
+            )
+            for start in range(0, count, _BLOCK_SIZE)
+        ]
+
+    def children(
+        self, node: NodeV1, source: Path, config: WorkspaceConfig
+    ) -> list[VirtualNodeSpec]:
+        if node.logical_path == "/":
+            return self._root_categories(source, config)
+        category = node.metadata.get("odf_category")
+        if category == "package_parts" and node.kind == NodeKind.CONTAINER:
+            return self._package_part_specs(node, source, config)
+        if category == "paragraphs" and node.kind == NodeKind.CONTAINER:
+            count = len(self._paragraph_elements(source, config))
+            return self._block_specs(
+                node.logical_path,
+                "Paragraphs",
+                count,
+                "odf_paragraph",
+                source_part="content.xml",
+                source_length=self._info(source, "content.xml", config).file_size,
+            )
+        if category == "tables" and node.kind == NodeKind.CONTAINER:
+            return [
+                VirtualNodeSpec(
+                    name=str(table.attrib.get(f"{{{_TABLE}}}name", f"Table {index + 1}")),
+                    kind=NodeKind.TABLE,
+                    logical_path=f"{node.logical_path}/{index}",
+                    metadata={"odf_table_index": index},
+                    source_part="content.xml",
+                    source_offset=0,
+                    source_length=self._info(source, "content.xml", config).file_size,
+                )
+                for index, table in enumerate(self._tables(source, config))
+            ]
+        if category == "sheets" and node.kind == NodeKind.CONTAINER:
+            return [
+                VirtualNodeSpec(
+                    name=str(sheet.attrib.get(f"{{{_TABLE}}}name", f"Sheet {index + 1}")),
+                    kind=NodeKind.SHEET,
+                    logical_path=f"{node.logical_path}/{index}",
+                    metadata={"odf_sheet_index": index},
+                    source_part="content.xml",
+                    source_offset=0,
+                    source_length=self._info(source, "content.xml", config).file_size,
+                )
+                for index, sheet in enumerate(self._sheets(source, config))
+            ]
+        if category == "slides" and node.kind == NodeKind.CONTAINER:
+            return [
+                VirtualNodeSpec(
+                    name=str(slide.attrib.get(f"{{{_DRAW}}}name", f"Slide {index + 1}")),
+                    kind=NodeKind.SLIDE,
+                    logical_path=f"{node.logical_path}/{index}",
+                    metadata={"odf_slide_index": index},
+                    source_part="content.xml",
+                    source_offset=0,
+                    source_length=self._info(source, "content.xml", config).file_size,
+                )
+                for index, slide in enumerate(self._slides(source, config))
+            ]
+        if node.kind == NodeKind.SHEET and "odf_sheet_index" in node.metadata:
+            row_count = self._sheet_row_count(source, int(node.metadata["odf_sheet_index"]), config)
+            return self._block_specs(
+                node.logical_path,
+                "Rows",
+                row_count,
+                "odf_sheet_rows",
+                source_part=node.source_ref.part if node.source_ref is not None else None,
+                source_length=node.source_ref.length if node.source_ref is not None else None,
+                sheet_index=int(node.metadata["odf_sheet_index"]),
+            )
+        return []
+
+    def _cell_value(self, cell: Any, config: WorkspaceConfig) -> tuple[Any, str]:
+        text = self._element_text(cell, config).strip()
+        value_type = str(cell.attrib.get(f"{{{_OFFICE}}}value-type", "string"))
+        raw_value = cell.attrib.get(f"{{{_OFFICE}}}value")
+        if value_type in {"float", "currency", "percentage"} and raw_value is not None:
+            try:
+                return float(raw_value), text
+            except ValueError:
+                return raw_value, text
+        if value_type == "boolean":
+            return cell.attrib.get(f"{{{_OFFICE}}}boolean-value") == "true", text
+        if value_type in {"date", "time"}:
+            return (
+                cell.attrib.get(f"{{{_OFFICE}}}{value_type}-value", raw_value or text),
+                text,
+            )
+        return cell.attrib.get(f"{{{_OFFICE}}}string-value", text), text
+
+    def _row_cells(
+        self, row: Any, row_number: int, config: WorkspaceConfig
+    ) -> list[dict[str, Any]]:
+        cells: list[dict[str, Any]] = []
+        for cell in row:
+            if cell.tag not in {
+                f"{{{_TABLE}}}table-cell",
+                f"{{{_TABLE}}}covered-table-cell",
+            }:
+                continue
+            repeated = self._repeat(
+                cell.attrib.get(f"{{{_TABLE}}}number-columns-repeated", "1"),
+                config,
+                "column",
+            )
+            if len(cells) + repeated > config.max_zip_entries:
+                raise ResourceLimitError("ODF row exceeds the structural item limit")
+            value, text = self._cell_value(cell, config)
+            for _ in range(repeated):
+                cells.append(
+                    {
+                        "column": len(cells) + 1,
+                        "row": row_number,
+                        "value": value,
+                        "text": text,
+                        "value_type": cell.attrib.get(f"{{{_OFFICE}}}value-type"),
+                        "formula": cell.attrib.get(f"{{{_TABLE}}}formula"),
+                    }
+                )
+        return cells
+
+    def _row_cell_count(self, row: Any, config: WorkspaceConfig) -> int:
+        count = 0
+        for cell in row:
+            if cell.tag not in {
+                f"{{{_TABLE}}}table-cell",
+                f"{{{_TABLE}}}covered-table-cell",
+            }:
+                continue
+            repeated = self._repeat(
+                cell.attrib.get(f"{{{_TABLE}}}number-columns-repeated", "1"),
+                config,
+                "column",
+            )
+            if repeated > config.max_index_nodes_per_file - count:
+                raise ResourceLimitError("ODF exceeds the expanded cell limit")
+            count += repeated
+        return count
+
+    def _expanded_row_count(self, container: Any, config: WorkspaceConfig) -> int:
+        row_count = 0
+        cell_count = 0
+        budget = config.max_index_nodes_per_file
+        for row in container.findall(f".//{{{_TABLE}}}table-row"):
+            repeated = self._repeat(
+                row.attrib.get(f"{{{_TABLE}}}number-rows-repeated", "1"), config, "row"
+            )
+            cells_per_row = self._row_cell_count(row, config)
+            if repeated > budget - row_count:
+                raise ResourceLimitError("ODF exceeds the expanded row limit")
+            if cells_per_row and repeated > (budget - cell_count) // cells_per_row:
+                raise ResourceLimitError("ODF exceeds the expanded cell limit")
+            row_count += repeated
+            cell_count += repeated * cells_per_row
+        return row_count
+
+    def _sheet(self, source: Path, sheet_index: int, config: WorkspaceConfig) -> Any:
+        sheets = self._sheets(source, config)
+        if sheet_index < 0 or sheet_index >= len(sheets):
+            raise InputValidationError("ODF sheet index is out of range")
+        return sheets[sheet_index]
+
+    def _sheet_row_count(self, source: Path, sheet_index: int, config: WorkspaceConfig) -> int:
+        return self._expanded_row_count(self._sheet(source, sheet_index, config), config)
+
+    def _sheet_rows(
+        self,
+        source: Path,
+        sheet_index: int,
+        start: int,
+        end: int,
+        config: WorkspaceConfig,
+    ) -> list[dict[str, Any]]:
+        sheet = self._sheet(source, sheet_index, config)
+        self._expanded_row_count(sheet, config)
+        result: list[dict[str, Any]] = []
+        current = 0
+        for row in sheet.findall(f".//{{{_TABLE}}}table-row"):
+            repeated = self._repeat(
+                row.attrib.get(f"{{{_TABLE}}}number-rows-repeated", "1"), config, "row"
+            )
+            overlap_start = max(start, current)
+            overlap_end = min(end, current + repeated)
+            for row_offset in range(overlap_start, overlap_end):
+                row_number = row_offset + 1
+                result.append(
+                    {"row": row_number, "cells": self._row_cells(row, row_number, config)}
+                )
+            current += repeated
+            if current >= end:
+                break
+        return result
+
+    def _table(self, source: Path, table_index: int, config: WorkspaceConfig) -> Any:
+        tables = self._tables(source, config)
+        if table_index < 0 or table_index >= len(tables):
+            raise InputValidationError("ODF table index is out of range")
+        return tables[table_index]
+
+    def _table_rows(
+        self,
+        source: Path,
+        table_index: int,
+        start: int,
+        end: int,
+        config: WorkspaceConfig,
+    ) -> tuple[list[list[str]], int]:
+        table = self._table(source, table_index, config)
+        total = self._expanded_row_count(table, config)
+        result: list[list[str]] = []
+        current = 0
+        for row in table.findall(f".//{{{_TABLE}}}table-row"):
+            repeated = self._repeat(
+                row.attrib.get(f"{{{_TABLE}}}number-rows-repeated", "1"), config, "row"
+            )
+            values = [
+                str(cell["value"] if cell["value"] is not None else "")
+                for cell in self._row_cells(row, current + 1, config)
+            ]
+            overlap = max(0, min(end, current + repeated) - max(start, current))
+            result.extend([list(values) for _ in range(overlap)])
+            current += repeated
+            if current >= end:
+                break
+        return result, total
+
+    def _slide_content(
+        self, source: Path, slide_index: int, config: WorkspaceConfig
+    ) -> list[dict[str, Any]]:
+        slides = self._slides(source, config)
+        if slide_index < 0 or slide_index >= len(slides):
+            raise InputValidationError("ODF slide index is out of range")
+        return [
+            {
+                "paragraph": index + 1,
+                "text": self._element_text(paragraph, config),
+            }
+            for index, paragraph in enumerate(slides[slide_index].findall(f".//{{{_TEXT}}}p"))
+        ]
+
+    def read(
+        self,
+        node: NodeV1,
+        source: Path,
+        offset: int,
+        limit: int,
+        config: WorkspaceConfig,
+    ) -> ReadResult:
+        category = node.metadata.get("odf_category")
+        if category == "metadata":
+            items = [self._metadata(source, config)]
+            return ReadResult(items=items[offset : offset + limit], total=1)
+        if node.metadata.get("block_type") == "odf_paragraph":
+            start = int(node.metadata["start"])
+            end = int(node.metadata["end"])
+            paragraphs = [
+                {
+                    "paragraph": index + 1,
+                    "kind": "heading" if element.tag == f"{{{_TEXT}}}h" else "paragraph",
+                    "text": self._element_text(element, config),
+                    "style": element.attrib.get(f"{{{_TEXT}}}style-name"),
+                }
+                for index, element in enumerate(
+                    self._paragraph_elements(source, config)[start:end], start
+                )
+            ]
+            return ReadResult(items=paragraphs[offset : offset + limit], total=len(paragraphs))
+        if node.metadata.get("block_type") == "odf_sheet_rows":
+            start = int(node.metadata["start"])
+            end = int(node.metadata["end"])
+            selected_start = min(start + offset, end)
+            selected_end = min(selected_start + limit, end)
+            rows = self._sheet_rows(
+                source,
+                int(node.metadata["sheet_index"]),
+                selected_start,
+                selected_end,
+                config,
+            )
+            return ReadResult(items=rows, total=end - start)
+        if node.kind == NodeKind.TABLE and "odf_table_index" in node.metadata:
+            table_rows, total = self._table_rows(
+                source,
+                int(node.metadata["odf_table_index"]),
+                offset,
+                offset + limit,
+                config,
+            )
+            return ReadResult(items=table_rows, total=total)
+        if node.kind == NodeKind.SLIDE and "odf_slide_index" in node.metadata:
+            content = self._slide_content(source, int(node.metadata["odf_slide_index"]), config)
+            selected = content[offset : offset + limit]
+            return ReadResult(
+                items=selected,
+                total=len(content),
+                text="\n".join(str(item["text"]) for item in selected),
+            )
+        if node.kind == NodeKind.PACKAGE_PART:
+            name = str(node.metadata["binary_part"])
+            info = self._info(source, name, config)
+            part_items: list[dict[str, Any]] = [
+                {
+                    "part": name,
+                    "size": info.file_size,
+                    "content_access": "read_binary",
+                }
+            ]
+            return ReadResult(items=part_items[offset : offset + limit], total=1)
+        return ReadResult(items=[], total=0)
+
+    def read_binary_part(
+        self,
+        node: NodeV1,
+        source: Path,
+        offset: int,
+        length: int,
+        config: WorkspaceConfig,
+    ) -> tuple[bytes, int]:
+        part = node.metadata.get("binary_part")
+        materialized_root = (
+            node.metadata.get("materialized_source") is True
+            and node.metadata.get("adapter_logical_path") == "/"
+        )
+        if (
+            not isinstance(part, str)
+            and node.source_ref is not None
+            and node.source_ref.part not in {None, "original"}
+            and not materialized_root
+        ):
+            part = node.source_ref.part
+        if not isinstance(part, str):
+            return super().read_binary_part(node, source, offset, length, config)
+        info = self._info(source, part, config)
+        try:
+            with ZipFile(source) as package, package.open(info) as member:
+                member.seek(offset)
+                return member.read(length), info.file_size
+        except (BadZipFile, OSError, RuntimeError) as error:
+            raise InputValidationError(f"unable to read ODF part: {part}") from error