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

agent_folder_workspace/adapters/manager.py

@@ -0,0 +1,178 @@
+"""Adapter selection and dispatch."""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+
+from agent_folder_workspace.adapters.base import BaseAdapter, ReadResult, VirtualNodeSpec
+from agent_folder_workspace.adapters.text import CsvAdapter, TextAdapter
+from agent_folder_workspace.config import WorkspaceConfig
+from agent_folder_workspace.errors import FolderWorkspaceError, InputValidationError
+from agent_folder_workspace.models import NodeV1
+from agent_folder_workspace.parser_workers import ParserWorkerPool
+
+_ISOLATED_ADAPTERS = frozenset(
+    {
+        "sqlite",
+        "structured_text",
+        "ooxml_spreadsheet",
+        "ooxml_word",
+        "ooxml_presentation",
+        "odf_text",
+        "odf_spreadsheet",
+        "odf_presentation",
+        "pdf",
+        "legacy_doc",
+        "legacy_xls",
+        "legacy_ppt",
+    }
+)
+
+
+def _create_direct_adapter(name: str) -> BaseAdapter | None:
+    """Lazily import risky parsers only when an in-process binary call needs one."""
+    if name == "sqlite":
+        from agent_folder_workspace.adapters.sqlite import SqliteAdapter
+
+        return SqliteAdapter()
+    if name == "structured_text":
+        from agent_folder_workspace.adapters.structured import StructuredTextAdapter
+
+        return StructuredTextAdapter()
+    if name == "ooxml_spreadsheet":
+        from agent_folder_workspace.adapters.ooxml import OoxmlAdapter
+
+        return OoxmlAdapter("spreadsheet")
+    if name == "ooxml_word":
+        from agent_folder_workspace.adapters.ooxml import OoxmlAdapter
+
+        return OoxmlAdapter("word")
+    if name == "ooxml_presentation":
+        from agent_folder_workspace.adapters.ooxml import OoxmlAdapter
+
+        return OoxmlAdapter("presentation")
+    if name == "odf_text":
+        from agent_folder_workspace.adapters.odf import OdfAdapter
+
+        return OdfAdapter("text")
+    if name == "odf_spreadsheet":
+        from agent_folder_workspace.adapters.odf import OdfAdapter
+
+        return OdfAdapter("spreadsheet")
+    if name == "odf_presentation":
+        from agent_folder_workspace.adapters.odf import OdfAdapter
+
+        return OdfAdapter("presentation")
+    if name == "pdf":
+        from agent_folder_workspace.adapters.pdf import PdfAdapter
+
+        return PdfAdapter()
+    if name == "legacy_doc":
+        from agent_folder_workspace.adapters.legacy_office import LegacyOfficeAdapter
+
+        return LegacyOfficeAdapter("doc")
+    if name == "legacy_xls":
+        from agent_folder_workspace.adapters.legacy_office import LegacyOfficeAdapter
+
+        return LegacyOfficeAdapter("xls")
+    if name == "legacy_ppt":
+        from agent_folder_workspace.adapters.legacy_office import LegacyOfficeAdapter
+
+        return LegacyOfficeAdapter("ppt")
+    return None
+
+
+class AdapterManager:
+    def __init__(self, *, isolate_parsers: bool = True) -> None:
+        fallback = BaseAdapter()
+        self._fallback = fallback
+        self._isolate_parsers = isolate_parsers
+        self._parser_workers: ParserWorkerPool | None = None
+        self._parser_workers_lock = threading.Lock()
+        self._adapters_lock = threading.Lock()
+        self._closed = False
+        self._adapters: dict[str, BaseAdapter] = {
+            "binary": fallback,
+            "text": TextAdapter(),
+            "csv": CsvAdapter(),
+        }
+
+    def _adapter(self, name: str) -> BaseAdapter:
+        with self._adapters_lock:
+            adapter = self._adapters.get(name)
+            if adapter is None:
+                adapter = _create_direct_adapter(name) or self._fallback
+                self._adapters[name] = adapter
+            return adapter
+
+    def _parser_pool(self, config: WorkspaceConfig) -> ParserWorkerPool:
+        with self._parser_workers_lock:
+            if self._closed:
+                raise FolderWorkspaceError("adapter manager is closed")
+            if self._parser_workers is None:
+                self._parser_workers = ParserWorkerPool(config.parser_max_workers)
+            elif self._parser_workers.max_workers != config.parser_max_workers:
+                raise InputValidationError(
+                    "parser_max_workers cannot change while an adapter manager is active"
+                )
+            return self._parser_workers
+
+    def _isolated(self, adapter_name: str) -> bool:
+        return self._isolate_parsers and adapter_name in _ISOLATED_ADAPTERS
+
+    def children(
+        self, node: NodeV1, source: Path, config: WorkspaceConfig
+    ) -> list[VirtualNodeSpec]:
+        if self._isolated(node.adapter):
+            return self._parser_pool(config).children(node.adapter, node, source, config)
+        return self._adapter(node.adapter).children(node, source, config)
+
+    def read(
+        self,
+        node: NodeV1,
+        source: Path,
+        offset: int,
+        limit: int,
+        config: WorkspaceConfig,
+    ) -> ReadResult:
+        if self._isolated(node.adapter):
+            return self._parser_pool(config).read(
+                node.adapter,
+                node,
+                source,
+                offset,
+                limit,
+                config,
+            )
+        return self._adapter(node.adapter).read(node, source, offset, limit, config)
+
+    def read_binary_part(
+        self,
+        node: NodeV1,
+        source: Path,
+        offset: int,
+        length: int,
+        config: WorkspaceConfig,
+    ) -> tuple[bytes, int]:
+        source_part = node.source_ref.part if node.source_ref is not None else None
+        if self._isolated(node.adapter) and source_part not in {None, "original"}:
+            return self._parser_pool(config).read_binary_part(
+                node.adapter,
+                node,
+                source,
+                offset,
+                length,
+                config,
+            )
+        return self._adapter(node.adapter).read_binary_part(node, source, offset, length, config)
+
+    def close(self) -> None:
+        with self._parser_workers_lock:
+            if self._closed:
+                return
+            self._closed = True
+            workers = self._parser_workers
+            self._parser_workers = None
+        if workers is not None:
+            workers.close()