patchr 0.1.0__py3-none-any.whl

picux/storage/tasks.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import copy
+import time
+from dataclasses import replace
+from typing import Any
+
+from picux.core import Domain, ProtocolTask, ProtocolTaskStatus
+
+
+class TaskBook:
+    """Protocol task storage with optional durable backing."""
+
+    def __init__(self, *, backing: Any | None = None) -> None:
+        self.backing = backing
+        self._tasks: dict[str, ProtocolTask] = {}
+
+    def saveTask(self, task: ProtocolTask | dict[str, Any]) -> dict[str, Any]:
+        item = task if isinstance(task, ProtocolTask) else taskFromObj(task)
+        if not item.taskId:
+            return {"ok": False, "error": "missing:taskId"}
+        self._tasks[item.taskId] = copy.deepcopy(item)
+        if self._backingEnabled() and hasattr(self.backing, "upsertTask"):
+            self.backing.upsertTask(item)
+        return {"ok": True, "taskId": item.taskId}
+
+    def getTask(self, taskId: str) -> dict[str, Any]:
+        taskId = str(taskId or "")
+        task = self._tasks.get(taskId)
+        if task is None and self._backingEnabled() and hasattr(self.backing, "fetchTask"):
+            task = self.backing.fetchTask(taskId)
+            if task:
+                self._tasks[taskId] = copy.deepcopy(task)
+        if task is None:
+            return {"ok": False, "error": "taskNotFound", "taskId": taskId}
+        return {"ok": True, "task": taskView(task)}
+
+    def getTaskByConversationId(self, conversationId: str) -> dict[str, Any]:
+        conversationId = str(conversationId or "")
+        if not conversationId:
+            return {"ok": False, "error": "missing:conversationId", "conversationId": ""}
+        direct = self.getTask(conversationId)
+        if direct.get("ok"):
+            return direct
+        self._loadBacking()
+        matches: list[ProtocolTask] = []
+        for task in self._tasks.values():
+            meta = task.meta if isinstance(task.meta, dict) else {}
+            outData = task.outData if isinstance(task.outData, dict) else {}
+            candidates = {
+                str(task.taskId or ""),
+                str(task.extRef or ""),
+                str(meta.get("conversationId", "") or ""),
+                str(outData.get("conversationId", "") or ""),
+            }
+            if conversationId in candidates:
+                matches.append(task)
+        if not matches:
+            return {"ok": False, "error": "conversationNotFound", "conversationId": conversationId}
+        matches.sort(key=lambda item: (item.updatedAt, item.createdAt, item.taskId), reverse=True)
+        return {"ok": True, "task": taskView(matches[0])}
+
+    def listTasks(self, filters: dict[str, Any] | None = None) -> dict[str, Any]:
+        self._loadBacking()
+        filters = filters or {}
+        tasks = list(self._tasks.values())
+        userId = str(filters.get("userId", "") or "")
+        domain = str(filters.get("domain", "") or "").lower()
+        status = str(filters.get("status", "") or "").lower()
+        channel = str(filters.get("channel", "") or "")
+        if userId:
+            tasks = [task for task in tasks if task.userId == userId]
+        if domain:
+            tasks = [task for task in tasks if task.domain.value == domain]
+        if status:
+            tasks = [task for task in tasks if task.status.value == status]
+        if channel:
+            tasks = [task for task in tasks if task.channel == channel]
+        tasks.sort(key=lambda item: (item.createdAt, item.taskId), reverse=True)
+        limit = _limit(filters.get("limit", 100))
+        return {"ok": True, "tasks": [taskView(task) for task in tasks[:limit]], "count": min(len(tasks), limit)}
+
+    def updateTask(self, taskId: str, updates: dict[str, Any]) -> dict[str, Any]:
+        current = self.getTask(taskId)
+        if not current.get("ok"):
+            return current
+        task = taskFromObj(current["task"])
+        status = str(updates.get("status", task.status.value) or task.status.value)
+        domain = str(updates.get("domain", task.domain.value) or task.domain.value)
+        nextTask = replace(
+            task,
+            domain=Domain(domain) if domain in Domain._value2member_map_ else task.domain,
+            status=ProtocolTaskStatus(status)
+            if status in ProtocolTaskStatus._value2member_map_
+            else task.status,
+            outData=updates.get("outData", task.outData) if isinstance(updates.get("outData", task.outData), dict) else task.outData,
+            meta=updates.get("meta", task.meta) if isinstance(updates.get("meta", task.meta), dict) else task.meta,
+            errorMsg=str(updates.get("errorMsg", task.errorMsg) or ""),
+            needsApproval=bool(updates.get("needsApproval", task.needsApproval)),
+            updatedAt=int(updates.get("updatedAt", int(time.time())) or int(time.time())),
+        )
+        self.saveTask(nextTask)
+        return {"ok": True, "task": taskView(nextTask)}
+
+    def _loadBacking(self) -> None:
+        if self.backing is None or not self._backingEnabled() or not hasattr(self.backing, "listTasks"):
+            return
+        for item in self.backing.listTasks():
+            task = item if isinstance(item, ProtocolTask) else taskFromObj(item)
+            if task.taskId:
+                self._tasks[task.taskId] = copy.deepcopy(task)
+
+    def _backingEnabled(self) -> bool:
+        if self.backing is None:
+            return False
+        return bool(getattr(self.backing, "enabled", True))
+
+
+def taskView(task: ProtocolTask) -> dict[str, Any]:
+    return {
+        "taskId": task.taskId,
+        "userId": task.userId,
+        "domain": task.domain.value,
+        "status": task.status.value,
+        "channel": task.channel,
+        "inData": task.inData,
+        "outData": task.outData,
+        "needsApproval": task.needsApproval,
+        "mandateId": task.mandateId,
+        "extRef": task.extRef,
+        "errorMsg": task.errorMsg,
+        "meta": task.meta,
+        "createdAt": task.createdAt,
+        "updatedAt": task.updatedAt,
+        "approvalBy": task.approvalBy,
+    }
+
+
+def taskFromObj(value: dict[str, Any]) -> ProtocolTask:
+    domain = str(value.get("domain", Domain.UNKNOWN.value) or Domain.UNKNOWN.value)
+    status = str(value.get("status", ProtocolTaskStatus.PENDING.value) or ProtocolTaskStatus.PENDING.value)
+    now = int(time.time())
+    return ProtocolTask(
+        taskId=str(value.get("taskId", "") or ""),
+        userId=str(value.get("userId", "api") or "api"),
+        domain=Domain(domain) if domain in Domain._value2member_map_ else Domain.UNKNOWN,
+        status=ProtocolTaskStatus(status)
+        if status in ProtocolTaskStatus._value2member_map_
+        else ProtocolTaskStatus.PENDING,
+        channel=str(value.get("channel", "api") or "api"),
+        inData=value.get("inData", {}) if isinstance(value.get("inData", {}), dict) else {},
+        outData=value.get("outData", {}) if isinstance(value.get("outData", {}), dict) else {},
+        needsApproval=bool(value.get("needsApproval", False)),
+        mandateId=str(value.get("mandateId", "") or ""),
+        extRef=str(value.get("extRef", "") or ""),
+        errorMsg=str(value.get("errorMsg", "") or ""),
+        meta=value.get("meta", {}) if isinstance(value.get("meta", {}), dict) else {},
+        createdAt=int(value.get("createdAt", now) or now),
+        updatedAt=int(value.get("updatedAt", now) or now),
+        approvalBy=_approvalBy(value.get("approvalBy")),
+    )
+
+
+def _approvalBy(value: Any) -> int | None:
+    if value in ("", None):
+        return None
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed or None
+
+
+def _limit(value: Any) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return 100
+    return max(1, min(parsed, 500))

picux/tools/__init__.py

@@ -0,0 +1,11 @@
+from .shared import BrowserCheckout, BrowserReader, ImageReader, MapTool, NLPTool, PortalBrowser, SharedToolbox
+
+__all__ = [
+    "BrowserCheckout",
+    "BrowserReader",
+    "ImageReader",
+    "MapTool",
+    "NLPTool",
+    "PortalBrowser",
+    "SharedToolbox",
+]