docuhand 0.1.0.dev1__py3-none-any.whl

docuhand/engine/pdf_plan.py

@@ -0,0 +1,49 @@
+"""Pure planning for export_pdf — page-range grammar, zero COM.
+
+v0.1 grammar: ``"all"`` / ``None`` (whole document) or a single contiguous
+1-based range ``"7"`` / ``"3-9"``.  Word's ExportAsFixedFormat only accepts
+one From/To pair anyway; comma lists would silently lie about fidelity.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+WD_EXPORT_FORMAT_PDF = 17
+WD_EXPORT_ALL_DOCUMENT = 0
+WD_EXPORT_FROM_TO = 3
+
+
+def parse_page_range(page_range: Any) -> tuple[int, int] | None:
+    """``"3-9"`` → (3, 9); ``"7"`` → (7, 7); ``None``/``"all"`` → None.
+
+    Raises ValueError with an llm-oriented message on anything else.
+    """
+    if page_range is None:
+        return None
+    if not isinstance(page_range, str):
+        raise ValueError(f"page_range must be a string like 'all', '7' or '3-9' (got {type(page_range).__name__})")
+    text = page_range.strip().lower()
+    if text in ("", "all", "*"):
+        return None
+    parts = text.replace("–", "-").replace("—", "-").split("-")
+    if len(parts) == 1:
+        try:
+            page = int(parts[0])
+        except ValueError:
+            raise ValueError(f"page_range must be 'all', a page number, or 'from-to' (got {page_range!r})") from None
+        if page < 1:
+            raise ValueError(f"page numbers are 1-based (got {page_range!r})")
+        return (page, page)
+    if len(parts) == 2:
+        try:
+            lo, hi = int(parts[0]), int(parts[1])
+        except ValueError:
+            raise ValueError(f"page_range must be 'all', a page number, or 'from-to' (got {page_range!r})") from None
+        if lo < 1 or hi < lo:
+            raise ValueError(f"page_range must satisfy 1 <= from <= to (got {page_range!r})")
+        return (lo, hi)
+    raise ValueError(
+        f"only a single contiguous page range is supported in v0.1 (got {page_range!r}); "
+        "call export_pdf once per range"
+    )

docuhand/engine/template_plan.py

@@ -0,0 +1,107 @@
+"""Pure planning for fill_template — zero COM, fully unit-testable.
+
+Template fill modes (v0.1):
+- ``content_controls``  map a control's Tag/Title to a data key
+- ``bookmarks``         replace the bookmark's range with the value
+- ``placeholders``      find/replace literal ``{{key}}`` tokens
+
+``auto`` runs all three in that order, so one template can mix mechanisms.
+The engine only ever receives validated (template, output, data, mode).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+# Wildcard Find pattern for leftover {{...}} scan (\{ and \} are escaped
+# braces in Word wildcard syntax; * = any run of characters).
+LEFTOVER_WILDCARD = r"\{\{*\}\}"
+
+MAX_KEY_LEN = 100
+MAX_VALUE_LEN = 200_000
+OUTPUT_FORMATS = {".doc": 0, ".docx": 16}  # SaveFormat numbers (pitfall #1)
+
+_MODES = ("auto", "content_controls", "bookmarks", "placeholders")
+
+
+def normalize_mode(mode: str) -> str:
+    m = (mode or "auto").strip().lower()
+    if m not in _MODES:
+        raise ValueError(
+            f"Unsupported mode: {mode!r} (use 'auto', 'placeholders', 'bookmarks' or 'content_controls')"
+        )
+    return m
+
+
+def validate_data(data: Any) -> dict[str, str]:
+    """Coerce to {str: str} and enforce key/value sanity rules.
+
+    Keys must be 1..MAX_KEY_LEN chars without braces or newlines (they are
+    spliced into a literal ``{{key}}`` search token and a Word Find argument,
+    both of which break on those).  Values are stringified and length-capped.
+    """
+    if not isinstance(data, dict):
+        raise ValueError("data must be a JSON object mapping keys to replacement text")
+    clean: dict[str, str] = {}
+    for key, value in data.items():
+        k = str(key)
+        if not (0 < len(k) <= MAX_KEY_LEN):
+            raise ValueError(f"data key length must be 1..{MAX_KEY_LEN}: {k[:40]!r}")
+        if any(ch in k for ch in "{}\r\n\x0b"):
+            raise ValueError(
+                f"data key must not contain braces or newlines: {k[:40]!r} "
+                "(the key is used inside a literal {{key}} token)"
+            )
+        v = value if isinstance(value, str) else str(value)
+        if len(v) > MAX_VALUE_LEN:
+            raise ValueError(
+                f"value for {k[:40]!r} exceeds {MAX_VALUE_LEN} chars; "
+                "split the document work into multiple calls"
+            )
+        clean[k] = v
+    return clean
+
+
+def resolve_output(template: Path, output: str | None) -> Path:
+    """Default output = '<stem>_filled' next to the template, same format.
+
+    The template file itself is sacred — same-path output is rejected and
+    only .doc/.docx targets are supported in v0.1.
+    """
+    t = template.expanduser()
+    if output:
+        out = Path(output).expanduser()
+    else:
+        out = t.with_name(t.stem + "_filled" + t.suffix.lower())
+    ext = out.suffix.lower()
+    if ext not in OUTPUT_FORMATS:
+        raise ValueError(
+            f"output_path extension must be .doc or .docx (got {ext or 'none'}); "
+            "use export_pdf for PDF output"
+        )
+    try:
+        same = out.exists() and out.samefile(t)
+    except OSError:
+        same = str(out.resolve()).lower() == str(t.resolve()).lower()
+    if same:
+        raise ValueError(
+            f"output_path must differ from the template ({t}); "
+            "fill_template never rewrites its own template"
+        )
+    return out
+
+
+def parse_bookmark_names(bookmark_args: Any) -> list[str]:
+    """Optional explicit bookmark list — None/omitted means 'all bookmarks'."""
+    if bookmark_args is None:
+        return []
+    if not isinstance(bookmark_args, (list, tuple)):
+        raise ValueError("bookmarks must be a list of bookmark names")
+    names: list[str] = []
+    for b in bookmark_args:
+        s = str(b).strip()
+        if not s:
+            raise ValueError("bookmark names must be non-empty")
+        names.append(s)
+    return names

docuhand/engine/templating.py

@@ -0,0 +1,316 @@
+"""Templating engine: fill templates via content controls / bookmarks /
+``{{placeholder}}`` tokens — STA-only, same failover contract as the rest
+of the engine (docs/pitfalls.md battle scars applied throughout):
+
+- **NameFarEast restore** (production scar #1): replacing ``Range.Text``
+  resets East-Asian font names to the theme default. Any value spliced
+  into a range whose text contains CJK gets its NameFarEast re-set from a
+  pre-read font snapshot, and the whole document gets a final sweep before
+  SaveAs2 — because SaveAs2 itself can reset it again.
+- **Literal Find, never wildcards**, for ``{{key}}`` tokens: data values
+  are user text; a wildcard pass would let ``[a-z]*`` in a value eat the
+  document. Keys are validated to exclude braces/newlines anyway.
+- Old-engine nets catch AttributeError (pitfall #13): ContentControls and
+  Find.Wildcards may not exist on Word 2007 / WPS oddities — degrade, don't die.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..errors import (
+    DocuhandError,
+    EngineUnavailableError,
+    FileNotFoundError,
+    OpenFailedError,
+    PasswordProtectedError,
+    TemplateFillError,
+)
+from .container_guard import detect_encryption, validate_container
+from .com_utils import (
+    _g,
+    _looks_encrypted,
+    _looks_like_arg_mismatch,
+    _short_exc,
+    file_claims_encrypted,
+)
+from .wd_constants import WD_DO_NOT_SAVE_CHANGES
+from pathlib import Path
+
+# SaveFormat numbers (pitfall #1 — drive Word by number, never by name)
+_CJK_RE = re.compile(r"[\u3000-\u9fff\uf900-\ufaff\uff00-\uffef]")
+
+
+def _has_cjk(text: str) -> bool:
+    return bool(_CJK_RE.search(text or ""))
+
+
+def _snapshot_font(font: Any) -> dict[str, Any]:
+    """Capture the fonts of a range BEFORE any text replacement."""
+    return {
+        "name": _g(lambda: font.Name),
+        "far_east": _g(lambda: font.NameFarEast),
+        "size": _g(lambda: font.Size),
+        "bold": _g(lambda: font.Bold),
+    }
+
+
+def _restore_font(font: Any, snap: dict[str, Any], value: str) -> None:
+    """Re-apply what the replacement may have clobbered.
+
+    Only touch NameFarEast when the spliced value actually contains CJK
+    (a pure-Latin value has no far-east glyphs, and re-asserting a CJK font
+    name over a Latin-only run is harmless but pointless).
+    """
+    if snap.get("far_east") and _has_cjk(value):
+        try:
+            font.NameFarEast = snap["far_east"]
+        except Exception:
+            pass
+    if snap.get("name"):
+        try:
+            font.Name = snap["name"]
+        except Exception:
+            pass
+
+
+def _replace_bookmarks(doc: Any, data: dict[str, str], wanted: list[str]) -> tuple[list[str], list[str]]:
+    """Fill bookmarks; returns (filled, missing) key lists."""
+    filled: list[str] = []
+    missing: list[str] = []
+    try:
+        count = int(doc.Bookmarks.Count)
+    except Exception:
+        count = 0
+    present: dict[str, Any] = {}
+    for i in range(count):
+        bm = _g(lambda i=i: doc.Bookmarks.Item(i + 1))
+        name = _g(lambda bm=bm: bm.Name)
+        if name:
+            present[name] = bm
+    targets = wanted if wanted else list(present.keys())
+    for key in targets:
+        if key not in data:
+            continue  # a bookmark without data is not an error — leave it
+        bm = present.get(key)
+        if bm is None:
+            missing.append(key)
+            continue
+        rng = _g(lambda bm=bm: bm.Range)
+        if rng is None:
+            missing.append(key)
+            continue
+        value = data[key]
+        snap = _snapshot_font(_g(lambda rng=rng: rng.Font, {}) or {})
+        try:
+            rng.Text = value
+        except Exception:
+            missing.append(key)
+            continue
+        _restore_font(_g(lambda rng=rng: rng.Font, {}) or {}, snap, value)
+        filled.append(key)
+    return filled, missing
+
+
+def _replace_placeholders(doc: Any, data: dict[str, str]) -> tuple[list[str], list[str]]:
+    """Literal {{key}} → value. Returns (filled, unmatched).
+
+    PORTABLE RECIPE (probe-verified on Word-hijack 12.0 and real KWPS):
+    ``Find.Execute(Replace:=wdReplaceAll)`` reports True but silently
+    replaces NOTHING on this engine family — the word-processor accepts
+    the call and drops the Replacement. The two-step works everywhere:
+    per iteration take a FRESH full-story Range + Find (ClearFormatting,
+    Forward, Wrap=wdFindContinue), Execute(token) with no Replace arg,
+    then set ``f.Parent.Text = value`` (Parent IS the matched range).
+    Loop until Execute returns False. Never let the data value leak into
+    FindText (injection would loop forever on self-matching values).
+    """
+    filled: list[str] = []
+    unmatched: list[str] = []
+    for key, value in data.items():
+        token = "{{" + key + "}}"
+        n = 0
+        while n < 500:  # hard cap: a self-replicating value cannot hang us
+            find = _g(lambda: doc.Content.Find, None)
+            if find is None:
+                break
+            try:
+                find.ClearFormatting()
+                find.Forward = True
+                find.Wrap = 1  # wdFindContinue — whole story from the top
+            except Exception:
+                pass
+            try:
+                hit = find.Execute(token)  # find only — NEVER Replace here
+            except Exception:
+                break
+            if not hit:
+                break
+            try:
+                find.Parent.Text = value  # replace the matched range
+            except Exception:
+                unmatched.append(key)
+                break
+            n += 1
+        if n:
+            filled.append(key)
+        else:
+            unmatched.append(key)
+    return filled, unmatched
+
+
+def _count_leftover_placeholders(doc: Any) -> list[str]:
+    """Scan for {{...}} remnants so the agent learns what did not fill.
+
+    Two-step find (same portable recipe as replacement): fresh Content
+    Range per iteration; Parent.Text reads the matched token.
+    """
+    leftovers: list[str] = []
+    for _ in range(50):  # report at most 50 — enough to act on
+        find = _g(lambda: doc.Content.Find, None)
+        if find is None:
+            break
+        try:
+            find.ClearFormatting()
+            find.Forward = True
+            find.Wrap = 1
+            find.MatchWildcards = True
+            hit = find.Execute(r"\{\{*\}\}")
+        except Exception:
+            # wildcard mode unsupported on this engine — fall back to
+            # literal scan of the two most common remnants
+            try:
+                find2 = doc.Content.Find
+                find2.ClearFormatting()
+                find2.MatchWildcards = False
+                find2.Wrap = 1
+                hit = find2.Execute("{{")
+            except Exception:
+                break
+            if not hit:
+                break
+            token = _g(lambda f2=find2: f2.Parent.Text, "")
+            if token:
+                leftovers.append(str(token)[:120])
+            try:
+                find2.Parent.Text = ""  # strip so the loop advances
+            except Exception:
+                break
+            continue
+        if not hit:
+            break
+        token = _g(lambda: find.Parent.Text, "")
+        if token:
+            leftovers.append(str(token)[:120])
+        try:
+            find.Parent.Text = ""  # strip so the loop advances
+        except Exception:
+            break
+    return leftovers
+
+
+def _replace_content_controls(doc: Any, data: dict[str, str]) -> tuple[list[str], list[str]]:
+    """Map ContentControl Tag/Title → data key. Optional path (2007 lacks it)."""
+    filled: list[str] = []
+    unmatched: list[str] = []
+    try:
+        controls = doc.ContentControls
+        count = int(controls.Count)
+    except AttributeError:
+        return filled, unmatched  # old engine — degrade silently
+    except Exception:
+        return filled, unmatched
+    for i in range(count):
+        cc = _g(lambda i=i: controls.Item(i + 1))
+        if cc is None:
+            continue
+        tag = _g(lambda cc=cc: cc.Tag, "") or ""
+        title = _g(lambda cc=cc: cc.Title, "") or ""
+        key = tag if tag in data else (title if title in data else None)
+        if key is None:
+            continue
+        try:
+            # Setting Range.Text keeps the control (and its styling) alive;
+            # plain text mapping only in v0.1.
+            cc.LockContents = False
+            cc.Range.Text = data[key]
+            filled.append(key)
+        except Exception:
+            unmatched.append(key)
+    return filled, unmatched
+
+
+def _final_far_east_sweep(doc: Any) -> None:
+    """Whole-document NameFarEast re-assertion before/after SaveAs2.
+
+    The production scar (200 government personnel files): replacing
+    ``Range.Text`` resets East-Asian font names document-wide, and SaveAs2
+    can reset them AGAIN. This sweep re-pins NameFarEast on the story
+    ranges that carry text — idempotent, and cheap compared to a
+    re-typeset.
+    """
+    for story_getter in (
+        lambda: doc.Content,
+        lambda: doc.StoryRanges.Item(1),  # wdMainTextStory
+    ):
+        rng = _g(story_getter, None)
+        if rng is None:
+            continue
+        font = _g(lambda rng=rng: rng.Font, None)
+        if font is None:
+            continue
+        current = _g(lambda font=font: font.NameFarEast, None)
+        if not current:
+            # engine lost the name entirely — pin the CJK workhorse default
+            for candidate in ("宋体", "SimSun"):
+                try:
+                    font.NameFarEast = candidate
+                    break
+                except Exception:
+                    continue
+
+
+class _FillOutcome:
+    __slots__ = ("filled", "missing", "controls_ok", "controls_bad", "leftovers", "bookmarks_seen")
+
+    def __init__(self) -> None:
+        self.filled: list[str] = []
+        self.missing: list[str] = []
+        self.controls_ok: list[str] = []
+        self.controls_bad: list[str] = []
+        self.leftovers: list[str] = []
+        self.bookmarks_seen = 0
+
+
+def _fill_open_document(
+    doc: Any,
+    data: dict[str, str],
+    mode: str,
+    bookmark_names: list[str],
+) -> _FillOutcome:
+    out = _FillOutcome()
+    try:
+        out.bookmarks_seen = int(_g(lambda: doc.Bookmarks.Count, 0) or 0)
+    except Exception:
+        pass
+
+    if mode in ("auto", "content_controls"):
+        ok, bad = _replace_content_controls(doc, data)
+        out.controls_ok, out.controls_bad = ok, bad
+
+    if mode in ("auto", "bookmarks"):
+        # only bookmark keys actually present in data participate
+        wanted = [n for n in bookmark_names if n in data] if bookmark_names else []
+        filled, missing = _replace_bookmarks(doc, data, wanted)
+        out.filled.extend(filled)
+        out.missing.extend(missing)
+
+    if mode in ("auto", "placeholders"):
+        remaining = {k: v for k, v in data.items() if k not in set(out.filled)}
+        filled, unmatched = _replace_placeholders(doc, remaining)
+        out.filled.extend(filled)
+        out.missing.extend(unmatched)
+
+    out.leftovers = _count_leftover_placeholders(doc)
+    return out

docuhand/engine/wd_constants.py

@@ -0,0 +1,23 @@
+"""Shared Word constant numbers — locale-independent (docs/pitfalls.md #1).
+
+Kept in a leaf module so engine submodules can share them without
+import cycles. Drive Word by number, never by display string.
+"""
+
+# document-close / quit disposition
+WD_DO_NOT_SAVE_CHANGES = 0
+WD_ALERTS_NONE = 0
+
+# ComputeStatistics selectors
+WD_STAT_WORDS = 0
+WD_STAT_PAGES = 2
+WD_STAT_PARAGRAPHS = 4
+
+# ExportAsFixedFormat / SaveAs PDF
+WD_EXPORT_FORMAT_PDF = 17
+WD_EXPORT_ALL_DOCUMENT = 0
+WD_EXPORT_FROM_TO = 3
+
+# SaveFormat
+WD_FORMAT_DOC = 0
+WD_FORMAT_DOCX = 16

docuhand/errors.py

@@ -0,0 +1,202 @@
+"""Structured error model — architecture decision #3.
+
+Errors are read by *LLMs*, not just humans. Every DocuHand error carries:
+- ``error_code``: stable machine token the agent can branch on
+- ``human_message``: what a person would want to see
+- ``llm_hint``: what the agent should *do next* to self-correct
+
+Tool implementations raise :class:`DocuhandError` subclasses; the server
+layer converts them into structured result dicts so the agent can read and
+recover from them instead of staring at a raw COM traceback.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class DocuhandError(Exception):
+    error_code = "DOCUHAND_ERROR"  # never used directly; subclasses override
+
+    def __init__(
+        self,
+        human_message: str,
+        *,
+        llm_hint: str = "",
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(human_message)
+        self.human_message = human_message
+        self.llm_hint = llm_hint
+        self.details = details or {}
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "ok": False,
+            "error": {
+                "error_code": self.error_code,
+                "human_message": self.human_message,
+                "llm_hint": self.llm_hint,
+                "details": self.details,
+            },
+        }
+
+
+class PathNotAllowedError(DocuhandError):
+    error_code = "PATH_NOT_ALLOWED"
+
+    def __init__(self, path: str, allowlist: list[str]) -> None:
+        super().__init__(
+            f"Path is outside the configured allowlist: {path}",
+            llm_hint=(
+                "Ask the user to add the directory to the DOCUHAND_ALLOWLIST "
+                "environment variable (os.pathsep-separated absolute dirs), "
+                "or to pass a path inside an already-allowed directory."
+            ),
+            details={"path": path, "allowlist": allowlist},
+        )
+
+
+class FileNotFoundError(DocuhandError):
+    error_code = "FILE_NOT_FOUND"
+
+    def __init__(self, path: str) -> None:
+        super().__init__(
+            f"File not found: {path}",
+            llm_hint=(
+                "Check the spelling of the path and that the drive letter is "
+                "correct. Use an absolute Windows path (e.g. D:\\Reports\\a.doc)."
+            ),
+            details={"path": path},
+        )
+
+
+class FileLockedError(DocuhandError):
+    error_code = "FILE_LOCKED"
+
+    def __init__(self, path: str, detail: str = "") -> None:
+        super().__init__(
+            f"File is locked by another process: {path}" + (f" ({detail})" if detail else ""),
+            llm_hint=(
+                "The file is probably open in Word/WPS right now. For a "
+                "read-only inspection retry once; to *modify* it, ask the "
+                "user to close it first (edit_open_document arrives in v0.1)."
+            ),
+            details={"path": path},
+        )
+
+
+class InvalidParamError(DocuhandError):
+    error_code = "INVALID_PARAM"
+
+
+class EngineUnavailableError(DocuhandError):
+    error_code = "ENGINE_UNAVAILABLE"
+
+    def __init__(self, attempts: list[dict[str, str]]) -> None:
+        super().__init__(
+            "No Office engine available (tried Word.Application and KWPS.Application)",
+            llm_hint=(
+                "Neither Microsoft Word nor WPS Office could be launched via "
+                "COM. Tell the user to install either one, or check that the "
+                "app is not stuck in a first-run dialog."
+            ),
+            details={"attempts": attempts},
+        )
+
+
+class OpenFailedError(DocuhandError):
+    error_code = "OPEN_FAILED"
+
+    def __init__(self, path: str, engine: str, com_error: str) -> None:
+        super().__init__(
+            f"{engine} failed to open: {path}",
+            llm_hint=(
+                "The file may be corrupted, password-protected, or in a "
+                "format this engine cannot open. Report is_format_recognized "
+                "from the inspection payload to the user and suggest trying "
+                "the other engine (DOCUHAND_ENGINE=wps or =word)."
+            ),
+            details={"path": path, "engine": engine, "com_error": com_error},
+        )
+
+
+class PasswordProtectedError(DocuhandError):
+    error_code = "FILE_PASSWORD_PROTECTED"
+
+    def __init__(self, path: str, engine: str) -> None:
+        super().__init__(
+            f"Document is password-protected, cannot be opened read-only: {path}",
+            llm_hint=(
+                "Opening it would require the password. Ask the user for the "
+                "password — never guess one. No other engine will help; do "
+                "not retry."
+            ),
+            details={"path": path, "engine": engine},
+        )
+
+
+class ComCallTimeoutError(DocuhandError):
+    error_code = "COM_TIMEOUT"
+
+    def __init__(self, timeout_s: float) -> None:
+        super().__init__(
+            f"COM operation timed out after {timeout_s:.0f}s",
+            llm_hint=(
+                "Word/WPS may be showing a modal dialog (first-run wizard, "
+                "activation, recovery prompt). Ask the user to check the "
+                "screen, then retry once."
+            ),
+            details={"timeout_s": timeout_s},
+        )
+
+
+class ReadOnlyError(DocuhandError):
+    error_code = "SERVER_READ_ONLY"
+
+    def __init__(self, tool: str) -> None:
+        super().__init__(
+            f"Server runs in read-only mode (DOCUHAND_READONLY); '{tool}' was blocked",
+            llm_hint=(
+                "The user locked this server to read-only operation. Only "
+                "inspect_document and extract_content are available. To allow "
+                "writes the user must remove DOCUHAND_READONLY from the server "
+                "config and restart it. Do not retry the same tool."
+            ),
+            details={"tool": tool},
+        )
+
+
+class TemplateFillError(DocuhandError):
+    error_code = "TEMPLATE_FILL_INCOMPLETE"
+
+    def __init__(self, path: str, detail: str, missing: list[str] | None = None) -> None:
+        super().__init__(
+            f"Template fill finished with problems: {path}",
+            llm_hint=(
+                "Check 'details.missing_keys' / 'details.problems'. Missing "
+                "bookmark keys mean the template lacks that bookmark — remove "
+                "the key from data or fix the template. Leftover {{placeholders}} "
+                "usually mean the data key spelling differs from the template."
+            ),
+            details={"path": path, "detail": detail, "missing_keys": missing or []},
+        )
+
+
+class EngineDeadError(DocuhandError):
+    error_code = "ENGINE_DIED"
+
+    def __init__(self, engine: str, com_error: str) -> None:
+        super().__init__(
+            f"The {engine} engine died mid-operation (RPC crash)",
+            llm_hint=(
+                "This engine instance crashed — the next call automatically "
+                "relaunches it (or fails over to the other engine). Retry once "
+                "before reporting a problem."
+            ),
+            details={"engine": engine, "com_error": com_error},
+        )
+
+
+class InternalError(DocuhandError):
+    error_code = "INTERNAL_ERROR"