docuhand 0.1.0.dev1__py3-none-any.whl

docuhand/tools/export_pdf.py

@@ -0,0 +1,92 @@
+"""export_pdf — print-fidelity PDF via the real Word/WPS layout engine.
+
+Tool layer: parse the page range with pure helpers (engine/pdf_plan.py),
+gate through allowlist + audit (export creates a NEW file but never
+touches the source, so it stays available in read-only mode), then run
+one engine export on the COM STA worker.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from ..engine import get_engine, get_worker
+from ..engine.pdf_plan import parse_page_range
+from ..errors import DocuhandError, FileNotFoundError, InternalError, InvalidParamError
+from ..safety import allowlist, audit
+
+TOOL_NAME = "export_pdf"
+
+
+def run(
+    path: str,
+    output_path: str | None = None,
+    page_range: str | None = None,
+) -> dict[str, Any]:
+    t0 = time.perf_counter()
+
+    # -- argument validation ---------------------------------------------------
+    src = Path(path).expanduser()
+    if not src.exists():
+        return FileNotFoundError(str(src)).to_dict()
+
+    try:
+        pages = parse_page_range(page_range)
+    except ValueError as exc:
+        return InvalidParamError(str(exc), llm_hint="Use page_range='all', '7' or '3-9', or omit it.").to_dict()
+
+    if output_path:
+        dst = Path(output_path).expanduser()
+        if dst.suffix.lower() != ".pdf":
+            return InvalidParamError(
+                f"output_path must end in .pdf (got {dst.suffix or 'none'})",
+                llm_hint="PDF export writes a .pdf file; pick a name like 'report.pdf'.",
+            ).to_dict()
+    else:
+        dst = src.with_suffix(".pdf")
+
+    try:
+        if dst.exists() and dst.samefile(src):
+            return InvalidParamError(
+                "output_path must differ from the source document",
+                llm_hint="Pick another name or omit output_path to write next to the source.",
+            ).to_dict()
+    except OSError:
+        pass
+
+    # -- safety gates ------------------------------------------------------------
+    try:
+        allowlist.check_allowed(str(src))
+        allowlist.check_allowed(str(dst))
+    except DocuhandError as exc:
+        audit.record(TOOL_NAME, str(src), ok=False, duration_ms=0, error_code=exc.error_code)
+        return exc.to_dict()
+
+    # -- execute -------------------------------------------------------------------
+    worker = get_worker()
+    engine = get_engine()
+    page_from, page_to = pages if pages else (None, None)
+    try:
+        result = worker.submit(engine.export_pdf, str(src), str(dst), page_from, page_to)
+    except DocuhandError as exc:
+        audit.record(
+            TOOL_NAME,
+            str(src),
+            ok=False,
+            duration_ms=(time.perf_counter() - t0) * 1000,
+            error_code=exc.error_code,
+        )
+        return exc.to_dict()
+    except Exception as exc:  # unknown engine crash — still structured
+        err = InternalError(
+            f"Unexpected error exporting {src.name}: {type(exc).__name__}: {exc}",
+            llm_hint="Retry once. If it persists, report error_code and details to the DocuHand repository.",
+            details={"source": str(src)},
+        )
+        audit.record(TOOL_NAME, str(src), ok=False, duration_ms=(time.perf_counter() - t0) * 1000, error_code=err.error_code)
+        return err.to_dict()
+
+    audit.record(TOOL_NAME, str(src), ok=True, duration_ms=result.get("duration_ms") or 0, engine=result.get("engine"))
+    return result

docuhand/tools/extract.py

@@ -0,0 +1,63 @@
+"""extract_content — text / tables / outline out of legacy .doc as JSON."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from ..engine import get_engine, get_worker
+from ..engine.extraction import extract_content as engine_extract
+from ..errors import DocuhandError, InvalidParamError, InternalError
+from ..safety import allowlist, audit
+
+TOOL_NAME = "extract_content"
+
+_WHAT = ("text", "tables", "outline")
+
+
+def run(path: str, what: str = "text") -> dict[str, Any]:
+    t0 = time.perf_counter()
+
+    what_norm = (what or "text").strip().lower()
+    if what_norm not in _WHAT:
+        return InvalidParamError(
+            f"what must be one of {list(_WHAT)} (got {what!r})",
+            llm_hint="'tables' pulls every table as a JSON grid; 'outline' returns the heading tree; 'text' is the full plain text.",
+        ).to_dict()
+
+    try:
+        allowlist.check_allowed(path)
+    except DocuhandError as exc:
+        audit.record(TOOL_NAME, path, ok=False, duration_ms=0, error_code=exc.error_code)
+        return exc.to_dict()
+
+    worker = get_worker()
+    engine = get_engine()
+    try:
+        result = worker.submit(engine_extract, engine, worker, path, what_norm)
+    except DocuhandError as exc:
+        audit.record(
+            TOOL_NAME,
+            path,
+            ok=False,
+            duration_ms=(time.perf_counter() - t0) * 1000,
+            error_code=exc.error_code,
+        )
+        return exc.to_dict()
+    except Exception as exc:
+        err = InternalError(
+            f"Unexpected error extracting content: {type(exc).__name__}: {exc}",
+            llm_hint="Retry once. If it persists, report error_code and details to the DocuHand repository.",
+            details={"path": path},
+        )
+        audit.record(TOOL_NAME, path, ok=False, duration_ms=(time.perf_counter() - t0) * 1000, error_code=err.error_code)
+        return err.to_dict()
+
+    audit.record(
+        TOOL_NAME,
+        path,
+        ok=True,
+        duration_ms=result.get("duration_ms") or 0,
+        engine=result.get("engine"),
+    )
+    return result

docuhand/tools/fill_template.py

@@ -0,0 +1,115 @@
+"""fill_template — fill bookmarks / {{placeholders}} / content controls.
+
+Tool layer: validate + plan with pure helpers (engine/template_plan.py),
+gate through the safety stack (read-only policy, allowlist, audit), then
+run one engine fill on the COM STA worker. The template file itself is
+never modified; failures come back as structured errors.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from ..engine import get_engine, get_worker
+from ..engine.template_plan import (
+    normalize_mode,
+    parse_bookmark_names,
+    resolve_output,
+    validate_data,
+)
+from ..errors import DocuhandError, FileNotFoundError, InternalError, InvalidParamError, TemplateFillError
+from ..safety import allowlist, audit
+from ..safety.policy import ensure_writable
+
+TOOL_NAME = "fill_template"
+
+
+def run(
+    template_path: str,
+    data: dict[str, Any],
+    output_path: str | None = None,
+    mode: str = "auto",
+    bookmarks: list[str] | None = None,
+) -> dict[str, Any]:
+    t0 = time.perf_counter()
+
+    # -- argument validation ---------------------------------------------------
+    try:
+        norm_mode = normalize_mode(mode)
+        clean_data = validate_data(data)
+        names = parse_bookmark_names(bookmarks)
+    except ValueError as exc:
+        return InvalidParamError(str(exc), llm_hint="Fix the argument and retry.").to_dict()
+
+    template = Path(template_path).expanduser()
+    if not template.exists():
+        return FileNotFoundError(str(template)).to_dict()
+
+    try:
+        output = resolve_output(template, output_path)
+    except ValueError as exc:
+        return InvalidParamError(
+            str(exc),
+            llm_hint="Choose a different output_path (extension .doc/.docx); the template is never rewritten.",
+        ).to_dict()
+
+    # -- safety gates ------------------------------------------------------------
+    try:
+        ensure_writable(TOOL_NAME)
+        allowlist.check_allowed(str(template))
+        allowlist.check_allowed(str(output))
+    except DocuhandError as exc:
+        audit.record(TOOL_NAME, str(template), ok=False, duration_ms=0, error_code=exc.error_code)
+        return exc.to_dict()
+
+    # -- execute -------------------------------------------------------------------
+    worker = get_worker()
+    engine = get_engine()
+    try:
+        result = worker.submit(
+            engine.fill_document,
+            str(template),
+            str(output),
+            clean_data,
+            norm_mode,
+            names,
+        )
+    except DocuhandError as exc:
+        audit.record(
+            TOOL_NAME,
+            str(template),
+            ok=False,
+            duration_ms=(time.perf_counter() - t0) * 1000,
+            error_code=exc.error_code,
+        )
+        return exc.to_dict()
+    except Exception as exc:  # unknown engine crash — still structured
+        err = InternalError(
+            f"Unexpected error filling {template.name}: {type(exc).__name__}: {exc}",
+            llm_hint="Retry once. If it persists, report error_code and details to the DocuHand repository.",
+            details={"template": str(template)},
+        )
+        audit.record(TOOL_NAME, str(template), ok=False, duration_ms=(time.perf_counter() - t0) * 1000, error_code=err.error_code)
+        return err.to_dict()
+
+    audit.record(TOOL_NAME, str(template), ok=True, duration_ms=result.get("duration_ms") or 0, engine=result.get("engine"))
+
+    # A fill that silently skipped keys is a warning, not a crash — surface it.
+    problems: list[str] = []
+    if result.get("missing_keys"):
+        problems.append(f"{len(result['missing_keys'])} data key(s) found no target in the template")
+    if result.get("leftover_placeholders"):
+        problems.append(f"{len(result['leftover_placeholders'])} {{{{...}}}} placeholder(s) remain unfilled")
+    if problems and norm_mode == "auto":
+        incomplete = TemplateFillError(
+            str(output),
+            "; ".join(problems),
+            missing=result.get("missing_keys") or None,
+        )
+        # success-shaped payload plus the structured warning — the file IS
+        # written; the agent decides whether it is good enough to keep.
+        result["ok"] = True
+        result["warning"] = incomplete.to_dict()["error"]
+    return result

docuhand/tools/inspect.py

@@ -0,0 +1,57 @@
+"""inspect_document — pre-flight health check for Word documents."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from ..engine import get_engine
+from ..errors import DocuhandError, InternalError
+from ..safety import allowlist, audit
+
+TOOL_NAME = "inspect_document"
+
+
+def run(path: str) -> dict[str, Any]:
+    t0 = time.perf_counter()
+
+    try:
+        allowlist.check_allowed(path)
+    except DocuhandError as exc:
+        audit.record(TOOL_NAME, path, ok=False, duration_ms=0, error_code=exc.error_code)
+        return exc.to_dict()
+
+    try:
+        result = get_engine().inspect_document(path)
+    except DocuhandError as exc:
+        audit.record(
+            TOOL_NAME,
+            path,
+            ok=False,
+            duration_ms=(time.perf_counter() - t0) * 1000,
+            error_code=exc.error_code,
+        )
+        return exc.to_dict()
+    except Exception as exc:  # unknown engine crash — still structured
+        err = InternalError(
+            f"Unexpected error: {type(exc).__name__}: {exc}",
+            llm_hint="Retry once. If it persists, report error_code and details to the DocuHand repository.",
+            details={"path": path},
+        )
+        audit.record(
+            TOOL_NAME,
+            path,
+            ok=False,
+            duration_ms=(time.perf_counter() - t0) * 1000,
+            error_code=err.error_code,
+        )
+        return err.to_dict()
+
+    audit.record(
+        TOOL_NAME,
+        path,
+        ok=True,
+        duration_ms=(time.perf_counter() - t0) * 1000,
+        engine=result.get("engine"),
+    )
+    return result

docuhand/tools/merge.py

@@ -0,0 +1,143 @@
+"""merge_documents — one template × N data rows → N filled files.
+
+Mail-merge style batch generation (the 干部任免审批表 production scar,
+rebuilt as a product tool). Per-row fault isolation: one bad row fails
+alone and the batch continues — the convert_documents survival guarantee,
+applied to generation.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from ..engine import get_engine, get_worker
+from ..engine.merge_plan import build_name, default_output_dir, resolve_collision
+from ..engine.template_plan import validate_data
+from ..errors import DocuhandError, InternalError, InvalidParamError
+from ..safety import allowlist, audit
+from ..safety.policy import ensure_writable
+
+TOOL_NAME = "merge_documents"
+
+
+def run(
+    template_path: str,
+    data_rows: list[dict[str, Any]],
+    output_dir: str | None = None,
+    name_pattern: str = "{i}_{name}",
+) -> dict[str, Any]:
+    t0 = time.perf_counter()
+
+    # -- argument validation ---------------------------------------------------
+    template = Path(template_path).expanduser()
+    if not template.exists():
+        from ..errors import FileNotFoundError
+
+        return FileNotFoundError(str(template)).to_dict()
+
+    if not isinstance(data_rows, list) or not data_rows:
+        return InvalidParamError(
+            "data_rows must be a non-empty array of row objects",
+            llm_hint="Each row is one output document: [{\"name\": \"张三\", ...}, ...].",
+        ).to_dict()
+    if len(data_rows) > 500:
+        return InvalidParamError(
+            f"at most 500 rows per call (got {len(data_rows)})",
+            llm_hint="Split very large merges into several calls; the COM session stays healthier.",
+        ).to_dict()
+
+    cleaned_rows: list[dict[str, str]] = []
+    for i, row in enumerate(data_rows):
+        try:
+            cleaned_rows.append(validate_data(row))
+        except ValueError as exc:
+            return InvalidParamError(
+                f"data_rows[{i}]: {exc}",
+                llm_hint="Fix this row and retry.",
+            ).to_dict()
+
+    out_dir = Path(output_dir).expanduser() if output_dir else default_output_dir(template)
+    try:
+        out_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        return DocuhandError(
+            f"Cannot create output directory {out_dir}: {exc}",
+            llm_hint="Check the path (drive letter, permissions) or pass a different output_dir.",
+            details={"output_dir": str(out_dir)},
+        ).to_dict()
+
+    ext = template.suffix.lower()
+    if ext not in (".doc", ".docx"):
+        return InvalidParamError(
+            f"template must be .doc or .docx (got {ext or 'none'})",
+            llm_hint="Pick a Word template file; PDF templates are not supported.",
+        ).to_dict()
+
+    # -- safety gates ------------------------------------------------------------
+    try:
+        ensure_writable(TOOL_NAME)
+        allowlist.check_allowed(str(template))
+        allowlist.check_allowed(str(out_dir))
+    except DocuhandError as exc:
+        audit.record(TOOL_NAME, str(template), ok=False, duration_ms=0, error_code=exc.error_code)
+        return exc.to_dict()
+
+    # -- plan outputs (collisions resolved before any engine work) -----------------
+    planned: list[tuple[dict[str, str], Path]] = []
+    for i, row in enumerate(cleaned_rows, start=1):
+        stem = build_name(name_pattern, i, row)
+        target = resolve_collision(out_dir, stem, ext)
+        planned.append((row, target))
+
+    # -- execute per row with fault isolation ----------------------------------------
+    worker = get_worker()
+    engine = get_engine()
+    results: list[dict[str, Any]] = []
+    counts = {"merged": 0, "failed": 0, "with_warnings": 0}
+
+    for i, (row, target) in enumerate(planned, start=1):
+        try:
+            r = worker.submit(engine.merge_one, str(template), str(target), row)
+        except DocuhandError as exc:
+            counts["failed"] += 1
+            results.append({"row": i, "output": str(target), "status": "failed", "error": exc.to_dict()["error"]})
+            audit.record(TOOL_NAME, str(template), ok=False, duration_ms=0, error_code=exc.error_code)
+            continue
+        except Exception as exc:
+            err = InternalError(
+                f"row {i}: {type(exc).__name__}: {exc}",
+                llm_hint="Retry once; if it persists report error_code to the DocuHand repository.",
+            )
+            counts["failed"] += 1
+            results.append({"row": i, "output": str(target), "status": "failed", "error": err.to_dict()["error"]})
+            audit.record(TOOL_NAME, str(template), ok=False, duration_ms=0, error_code=err.error_code)
+            continue
+
+        counts["merged"] += 1
+        entry: dict[str, Any] = {
+            "row": i,
+            "output": str(target),
+            "status": "merged",
+            "engine": r.get("engine"),
+            "output_size_bytes": r.get("output_size_bytes"),
+        }
+        if r.get("row_warning"):
+            counts["with_warnings"] += 1
+            entry["warning"] = r["row_warning"]
+        results.append(entry)
+        audit.record(TOOL_NAME, str(template), ok=True, duration_ms=r.get("duration_ms") or 0, engine=r.get("engine"))
+
+    return {
+        "ok": counts["failed"] < len(planned),  # total engine failure only if every row failed
+        "tool": TOOL_NAME,
+        "template": str(template),
+        "output_dir": str(out_dir),
+        "summary": {
+            **counts,
+            "rows": len(planned),
+            "duration_ms": round((time.perf_counter() - t0) * 1000),
+        },
+        "results": results,
+    }

docuhand-0.1.0.dev1.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.5
+Name: docuhand
+Version: 0.1.0.dev1
+Summary: Give your AI agent hands to operate real Word & WPS documents on Windows — an MCP server driving real Office apps via COM.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: mcp<2,>=1.2
+Requires-Dist: olefile>=0.47
+Requires-Dist: pywin32<312,>=306
+Description-Content-Type: text/markdown
+
+# docuhand
+Give your AI agent hands to operate real Word &amp; WPS documents on Windows

docuhand-0.1.0.dev1.dist-info/RECORD

@@ -0,0 +1,36 @@
+docuhand/__init__.py,sha256=xSZFzhFrXp33G8dvHJ4wvsUPHP7JBr2Rm1sljA_puJU,110
+docuhand/__main__.py,sha256=9it1my_mM7xBpDh79QSi7FAvZD3Vki3GQFPJIDZw_zs,64
+docuhand/_compat.py,sha256=Ue5Uo8_nKDpfkmI5lGBIeLY_JG31I-jTstlMrOhoET0,984
+docuhand/errors.py,sha256=ia1ikuJjZHged-7HB_V1wjMm0AcItBJzRKnzTea9cSc,7199
+docuhand/server.py,sha256=tlJjWLeOqouPvOsR1OLuIOOyXDz-z6cAf28iY22-ZdY,9346
+docuhand/engine/__init__.py,sha256=SMAJZMblCqWR39XWPlcb6_fMHhDk2xMIwxTOOxoT4nA,1047
+docuhand/engine/com_thread.py,sha256=srRaHYjbv99vOzWLtKBeeD8yaKKJwnpzWitwEVBviOo,3139
+docuhand/engine/com_utils.py,sha256=cNmIDXHuxSUSwvthNGfCCGvLEN4JKaAddHG2V6_TGKA,1707
+docuhand/engine/container_guard.py,sha256=BTE2v-LkDL9TCj5cgNLp3OM7ubrM77VkfE-5aicyRHw,7111
+docuhand/engine/convert_plan.py,sha256=ysajq0Ikv2IwQ7WLXm6PI6cwFJb2wixym55c_QAUNO4,1632
+docuhand/engine/edit_plan.py,sha256=qSBR3f9W7gXcR7tL4R4Y2V5SgNKVMS_8zs1iInBjVQc,3098
+docuhand/engine/extraction.py,sha256=bmDi9HN4CTrgfMNsrNpL9Lr6PX-2C40RXovNgYUho7Q,6379
+docuhand/engine/live_edit.py,sha256=hjYMU72HoiOFNUEF4JXFqfb62CgodkjQ3mdgdV2zApY,7477
+docuhand/engine/merge_plan.py,sha256=t1hAoQ4msDmTZqq_snfQpIy1gWOZGe8Ki0f6b4n8tzk,1972
+docuhand/engine/office_app.py,sha256=zWoyUDO5cYu88KrxO0vmxcTmQDQu57VIN-noXKa8ZKU,32036
+docuhand/engine/pdf_plan.py,sha256=x9kxHWE4HH8dquzC5TxjhzwYXajx8oB3WWmiWYSHNEc,1898
+docuhand/engine/template_plan.py,sha256=bPORNXxe4WpURTrY54jwGeWF4SrOt98Ee-BvGB3zi4c,3910
+docuhand/engine/templating.py,sha256=PkQT3inty0PDFMJfIlLj_H2554hD9u0t2aClF4qKMLc,11137
+docuhand/engine/wd_constants.py,sha256=MT0YLnaiDo5opf86C9rl_4I9ukPnTff7tnH8DazsNLg,547
+docuhand/safety/__init__.py,sha256=HbcyxKcUAaotJ5-sXh6clm1oca9KepfGKzzgTTnSuI8,315
+docuhand/safety/allowlist.py,sha256=a7ooM9aBjnni2EY_YSnq4dIYN0bPIeWw61VFRx9fLks,1190
+docuhand/safety/audit.py,sha256=_jQNEDrrUqaykdFuLTNTziqACGfRGpf-Z4ZZlrwYxAw,1387
+docuhand/safety/policy.py,sha256=J9uiSCW3Maszeg6-qS9BNj0Qav8ZIISQu7y4WLKJcIQ,877
+docuhand/tools/__init__.py,sha256=GadG7o7O1tWO4jjTPrWx6R_4u7xiJPW9MXqSf-fMsZs,344
+docuhand/tools/convert.py,sha256=4hCMRGmIGSPiza2ujcRJc4kejkcMV0ZJjsw0t7vVZ5k,8527
+docuhand/tools/edit_open.py,sha256=dwlClXEWTidHlOEWC7i3swV0ALIhE1sy7QQvNldE52c,3458
+docuhand/tools/export_pdf.py,sha256=sQjtJ0q1-JAb2kRzj9Hui3ojIXUOKXL_S4Rj3IYBvIY,3441
+docuhand/tools/extract.py,sha256=ToJwVk3_U6ZEKxJaJRbGSMRuPlb7VB_8z6mdb_nV464,2086
+docuhand/tools/fill_template.py,sha256=7G5CNDdVoUEDfeER8u1ldyC8B8hWe6kiERqGuQPRi0o,4304
+docuhand/tools/inspect.py,sha256=O8dayfhlyrFpCZdTfO2rU_f1-4nLvByMurP9wENCiYs,1611
+docuhand/tools/merge.py,sha256=tDC4hQEiBPfu2FSvV0TZHkIzxu27OImVvrbP_u0IyVQ,5681
+docuhand-0.1.0.dev1.dist-info/METADATA,sha256=z3nNmRe3Q96wZ4gGyn9fwCfgHGQu9LGQho285eO81gg,479
+docuhand-0.1.0.dev1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+docuhand-0.1.0.dev1.dist-info/entry_points.txt,sha256=c0HU90ex3jSZhvCHIelsFweolWagjDOm1UUCcmoDqDQ,50
+docuhand-0.1.0.dev1.dist-info/licenses/LICENSE,sha256=hPw9rU1TQ7AAqcXcmBq2qtrQyq1-Yo-e6u-BFy_ndJ4,1088
+docuhand-0.1.0.dev1.dist-info/RECORD,,

docuhand-0.1.0.dev1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

docuhand-0.1.0.dev1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docuhand = docuhand.server:main

docuhand-0.1.0.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Frank Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.