python-hwpx-automation 6.0.3__py3-none-any.whl

hwpx_automation/ops_services/package_validation.py

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import dataclasses
+import logging
+import re
+from dataclasses import asdict
+from typing import Any, Dict, List, Optional, Sequence, cast
+from xml.etree import ElementTree as ET
+
+from ..upstream import (
+    ValidationReport,
+    create_text_extractor,
+    open_package,
+    validate_document_path,
+)
+
+from .context import DocumentContext
+
+logger = logging.getLogger("hwpx_automation.hwpx_ops")
+
+
+class PackageValidationService:
+    def __init__(self, context: DocumentContext) -> None:
+        self._context = context
+
+    def package_parts(self, path: str) -> Dict[str, Any]:
+        resolved = self._context._resolve_path(path)
+        package = open_package(resolved)
+        parts = sorted(package.part_names())
+        return {"parts": parts}
+
+    def package_get_text(
+        self, path: str, part_name: str, encoding: str | None = None
+    ) -> Dict[str, Any]:
+        resolved = self._context._resolve_path(path)
+        package = open_package(resolved)
+        text = package.get_text(part_name, encoding=encoding or "utf-8")
+        return {"text": text}
+
+    def repair_hwpx(
+        self,
+        source: str,
+        output: str,
+        *,
+        recover: bool = False,
+        overwrite: bool = False,
+        max_entry_size: int = 64 * 1024 * 1024,
+        max_total_size: int = 512 * 1024 * 1024,
+        max_source_size: int = 512 * 1024 * 1024,
+    ) -> Dict[str, Any]:
+        try:
+            from hwpx.tools.package_validator import validate_editor_open_safety
+            from hwpx.tools.package_validator import validate_package
+            from hwpx.tools.repair import repair_from_recovered, repair_repack
+        except Exception as exc:  # pragma: no cover - depends on installed python-hwpx
+            raise self._context._new_error(
+                "REPAIR_UNAVAILABLE",
+                "python-hwpx repair support is not available; install a python-hwpx build with hwpx.tools.repair",
+                hint="Upgrade python-hwpx to a version that includes hwpx.tools.repair and hwpx.tools.recover.",
+            ) from exc
+
+        source_path = self._context._resolve_path(source)
+        output_path = self._context.storage.resolve_output_path(output)
+        if recover:
+            result = repair_from_recovered(
+                source_path,
+                output_path,
+                overwrite=overwrite,
+                max_entry_size=max_entry_size,
+                max_total_size=max_total_size,
+                max_source_size=max_source_size,
+            )
+        else:
+            result = repair_repack(
+                source_path,
+                output_path,
+                overwrite=overwrite,
+                max_entry_size=max_entry_size,
+                max_total_size=max_total_size,
+            )
+        validation = validate_package(output_path)
+        open_safety = validate_editor_open_safety(output_path)
+        return {
+            "outputPath": self._context._relative_path(output_path),
+            "entries": list(result.entries),
+            "entryCount": len(result.entries),
+            "reordered": result.reordered,
+            "crcOk": result.crc_ok,
+            "recovered": result.recovered,
+            "validatePackage": {
+                "ok": validation.ok,
+                "errors": [str(issue) for issue in validation.errors],
+                "warnings": [str(issue) for issue in validation.warnings],
+            },
+            "openSafety": open_safety.to_dict(),
+        }
+
+    def list_master_pages_histories_versions(self, path: str) -> Dict[str, Any]:
+        document, _ = self._context._open_document(path)
+        master_pages = [
+            getattr(page, "part_name", None) for page in document.master_pages
+        ]
+        histories = [
+            getattr(history, "part_name", None) for history in document.histories
+        ]
+        version = document.version
+        version_info = (
+            asdict(cast(Any, version)) if version and dataclasses.is_dataclass(version) else None
+        )
+        return {
+            "masterPages": master_pages,
+            "histories": histories,
+            "versions": version_info,
+        }
+
+    def validate_structure(self, path: str, level: str = "basic") -> Dict[str, Any]:
+        resolved = self._context._resolve_path(path)
+        report: ValidationReport = validate_document_path(resolved)
+        issues = [
+            {
+                "part": issue.part_name,
+                "message": issue.message,
+            }
+            for issue in report.issues
+        ]
+        return {"ok": not issues, "issues": issues}
+
+    def lint_text_conventions(
+        self,
+        path: str,
+        *,
+        max_line_len: Optional[int] = None,
+        forbid_patterns: Optional[Sequence[str]] = None,
+    ) -> Dict[str, Any]:
+        resolved = self._context._resolve_path(path)
+        patterns = [re.compile(pat) for pat in (forbid_patterns or [])]
+        warnings: List[Dict[str, Any]] = []
+        with create_text_extractor(resolved) as extractor:
+            for paragraph in extractor.iter_document_paragraphs():
+                text = paragraph.text()
+                if max_line_len is not None and len(text) > max_line_len:
+                    warnings.append(
+                        {
+                            "paragraphIndex": paragraph.index,
+                            "message": f"Paragraph exceeds {max_line_len} characters",
+                        }
+                    )
+                for pattern in patterns:
+                    if pattern.search(text):
+                        warnings.append(
+                            {
+                                "paragraphIndex": paragraph.index,
+                                "message": f"Pattern '{pattern.pattern}' found",
+                            }
+                        )
+        return {"warnings": warnings}
+
+    def package_get_xml(self, path: str, part_name: str) -> Dict[str, Any]:
+        resolved = self._context._resolve_path(path)
+        package = open_package(resolved)
+        element = package.get_xml(part_name)
+
+        xml_string = ET.tostring(element, encoding="unicode")
+        return {"xmlString": xml_string}

hwpx_automation/ops_services/planning.py

@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Sequence
+from uuid import uuid4
+
+from ..core.plan import (
+    ApplyEditInput,
+    GetContextInput,
+    PipelineError,
+    PlanEditInput,
+    PlanManager,
+    PreviewEditInput,
+    SearchHitModel,
+    SearchInput,
+    SearchOutput,
+)
+from ..metadata import tools_meta
+from ..upstream import (
+    create_text_extractor,
+)
+
+from .context import DocumentContext
+
+logger = logging.getLogger("hwpx_automation.hwpx_ops")
+
+
+class PlanningService:
+    def __init__(self, context: DocumentContext) -> None:
+        self._context = context
+        self._manager = PlanManager()
+
+    @property
+    def plan_manager(self) -> PlanManager:
+        return self._manager
+
+    def _ensure_planner_document(self, doc_id: str, path: str) -> None:
+        resolved = self._context._resolve_path(path)
+        paragraphs: List[str] = []
+        with create_text_extractor(resolved) as extractor:
+            for paragraph in extractor.iter_document_paragraphs():
+                paragraphs.append(paragraph.text(preserve_breaks=True))
+        self._manager.register_document(doc_id, "\n".join(paragraphs))
+
+    def plan_edit(
+        self,
+        *,
+        path: str,
+        operations: Sequence[Dict[str, Any]],
+        trace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload = PlanEditInput.model_validate(
+            {"path": path, "operations": operations, "traceId": trace_id}
+        )
+        doc_path = payload.path_or_none()
+        if doc_path is not None:
+            self._ensure_planner_document(payload.doc_id, doc_path)
+        trace = payload.trace_id or f"plan-{uuid4().hex}"
+        try:
+            record = self._manager.create_plan_record(
+                payload.doc_id, payload.operations, trace_id=trace
+            )
+        except PipelineError as error:
+            return self._manager.error_response(payload.doc_id, trace, error)
+        return self._manager.plan_response(record)
+
+    def preview_edit(
+        self,
+        *,
+        plan_id: str,
+        trace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload = PreviewEditInput.model_validate(
+            {"planId": plan_id, "traceId": trace_id}
+        )
+        trace = payload.trace_id or payload.plan_id
+        try:
+            preview = self._manager.preview_plan_record(payload.plan_id)
+        except PipelineError as error:
+            plan = self._manager.get_plan_record(payload.plan_id)
+            doc_id = plan.doc_id if plan is not None else payload.plan_id
+            return self._manager.error_response(
+                doc_id, trace, error, plan_id=payload.plan_id
+            )
+        return self._manager.preview_response(preview)
+
+    def apply_edit(
+        self,
+        *,
+        plan_id: str,
+        confirm: bool,
+        idempotency_key: Optional[str] = None,
+        trace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload = ApplyEditInput.model_validate(
+            {
+                "planId": plan_id,
+                "confirm": confirm,
+                "idempotencyKey": idempotency_key,
+                "traceId": trace_id,
+            }
+        )
+        trace = payload.trace_id or payload.plan_id
+        try:
+            result = self._manager.apply_plan_record(
+                payload.plan_id,
+                confirm=payload.confirm,
+                idempotency_key=payload.idempotency_key,
+            )
+        except PipelineError as error:
+            plan = self._manager.get_plan_record(payload.plan_id)
+            doc_id = plan.doc_id if plan is not None else payload.plan_id
+            template = (
+                tools_meta.ERROR_PREVIEW_REQUIRED
+                if error.error_code == "PREVIEW_REQUIRED"
+                else None
+            )
+            return self._manager.error_response(
+                doc_id,
+                trace,
+                error,
+                plan_id=payload.plan_id,
+                next_action=template,
+            )
+        plan_record = self._manager.get_plan_record(payload.plan_id)
+        if plan_record is None:  # pragma: no cover - defensive
+            raise self._context._new_error(
+                "PLAN_RECORD_MISSING",
+                "plan record missing after apply",
+                details={"planId": payload.plan_id},
+            )
+        return self._manager.apply_response(plan_record, result, trace)
+
+    def search(
+        self,
+        *,
+        path: str,
+        pattern: str,
+        scope: Optional[str] = None,
+        is_regex: bool = False,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        payload = SearchInput.model_validate(
+            {
+                "path": path,
+                "pattern": pattern,
+                "scope": scope,
+                "is_regex": is_regex,
+                "limit": limit,
+            }
+        )
+        doc_path = payload.path_or_none()
+        if doc_path is not None:
+            self._ensure_planner_document(payload.doc_id, doc_path)
+        try:
+            hits = self._manager.search_document(payload.doc_id, payload)
+        except PipelineError as error:
+            raise self._context._new_error(
+                "PIPELINE_ERROR",
+                error.message,
+                details={"pipelineCode": error.error_code},
+                hint=error.hint,
+            ) from error
+        models = [
+            SearchHitModel(
+                nodeId=hit.node_id,
+                paragraphIndex=hit.paragraph_index,
+                match=hit.match,
+                context=hit.context,
+            )
+            for hit in hits
+        ]
+        return SearchOutput(matches=models).model_dump(by_alias=True)
+
+    def get_context(
+        self,
+        *,
+        path: str,
+        target: Dict[str, Any],
+        window: int = 1,
+    ) -> Dict[str, Any]:
+        payload = GetContextInput.model_validate(
+            {"path": path, "target": target, "window": window}
+        )
+        doc_path = payload.path_or_none()
+        if doc_path is not None:
+            self._ensure_planner_document(payload.doc_id, doc_path)
+        try:
+            view = self._manager.context_window(
+                payload.doc_id, payload.target, window=payload.window
+            )
+        except PipelineError as error:
+            raise self._context._new_error(
+                "PIPELINE_ERROR",
+                error.message,
+                details={"pipelineCode": error.error_code},
+                hint=error.hint,
+            ) from error
+        return view.model_dump(by_alias=True)