autoglm-gui 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

AutoGLM_GUI/models/history.py

@@ -0,0 +1,96 @@
+"""Conversation history data models."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Literal
+from uuid import uuid4
+
+
+@dataclass
+class ConversationRecord:
+    """单条对话记录."""
+
+    id: str = field(default_factory=lambda: str(uuid4()))
+
+    # 任务信息
+    task_text: str = ""  # 用户输入的任务
+    final_message: str = ""  # 最终结果消息
+
+    # 执行信息
+    success: bool = False
+    steps: int = 0
+    start_time: datetime = field(default_factory=datetime.now)
+    end_time: datetime | None = None
+    duration_ms: int = 0  # 执行时长（毫秒）
+
+    # 来源标记
+    source: Literal["chat", "layered", "scheduled"] = "chat"
+    source_detail: str = ""  # 定时任务名称 or session_id
+
+    # 错误信息
+    error_message: str | None = None
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "id": self.id,
+            "task_text": self.task_text,
+            "final_message": self.final_message,
+            "success": self.success,
+            "steps": self.steps,
+            "start_time": self.start_time.isoformat(),
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "duration_ms": self.duration_ms,
+            "source": self.source,
+            "source_detail": self.source_detail,
+            "error_message": self.error_message,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ConversationRecord":
+        """从字典创建实例."""
+        return cls(
+            id=data.get("id", str(uuid4())),
+            task_text=data.get("task_text", ""),
+            final_message=data.get("final_message", ""),
+            success=data.get("success", False),
+            steps=data.get("steps", 0),
+            start_time=datetime.fromisoformat(data["start_time"])
+            if data.get("start_time")
+            else datetime.now(),
+            end_time=datetime.fromisoformat(data["end_time"])
+            if data.get("end_time")
+            else None,
+            duration_ms=data.get("duration_ms", 0),
+            source=data.get("source", "chat"),
+            source_detail=data.get("source_detail", ""),
+            error_message=data.get("error_message"),
+        )
+
+
+@dataclass
+class DeviceHistory:
+    """设备对话历史（一个设备一个文件）."""
+
+    serialno: str
+    records: list[ConversationRecord] = field(default_factory=list)
+    last_updated: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "serialno": self.serialno,
+            "records": [r.to_dict() for r in self.records],
+            "last_updated": self.last_updated.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DeviceHistory":
+        """从字典创建实例."""
+        return cls(
+            serialno=data.get("serialno", ""),
+            records=[ConversationRecord.from_dict(r) for r in data.get("records", [])],
+            last_updated=datetime.fromisoformat(data["last_updated"])
+            if data.get("last_updated")
+            else datetime.now(),
+        )

AutoGLM_GUI/models/scheduled_task.py

@@ -0,0 +1,71 @@
+"""Scheduled task data models."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from uuid import uuid4
+
+
+@dataclass
+class ScheduledTask:
+    """定时任务定义."""
+
+    id: str = field(default_factory=lambda: str(uuid4()))
+
+    # 基础信息
+    name: str = ""  # 任务名称
+    workflow_uuid: str = ""  # 关联的 Workflow UUID
+    device_serialno: str = ""  # 绑定的设备 serialno
+
+    # 调度配置
+    cron_expression: str = ""  # Cron 表达式 (如 "0 8 * * *")
+    enabled: bool = True  # 是否启用
+
+    # 元数据
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+
+    # 最近执行信息（只记录最后一次）
+    last_run_time: datetime | None = None
+    last_run_success: bool | None = None
+    last_run_message: str | None = None
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "workflow_uuid": self.workflow_uuid,
+            "device_serialno": self.device_serialno,
+            "cron_expression": self.cron_expression,
+            "enabled": self.enabled,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "last_run_time": self.last_run_time.isoformat()
+            if self.last_run_time
+            else None,
+            "last_run_success": self.last_run_success,
+            "last_run_message": self.last_run_message,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ScheduledTask":
+        """从字典创建实例."""
+        return cls(
+            id=data.get("id", str(uuid4())),
+            name=data.get("name", ""),
+            workflow_uuid=data.get("workflow_uuid", ""),
+            device_serialno=data.get("device_serialno", ""),
+            cron_expression=data.get("cron_expression", ""),
+            enabled=data.get("enabled", True),
+            created_at=datetime.fromisoformat(data["created_at"])
+            if data.get("created_at")
+            else datetime.now(),
+            updated_at=datetime.fromisoformat(data["updated_at"])
+            if data.get("updated_at")
+            else datetime.now(),
+            last_run_time=datetime.fromisoformat(data["last_run_time"])
+            if data.get("last_run_time")
+            else None,
+            last_run_success=data.get("last_run_success"),
+            last_run_message=data.get("last_run_message"),
+        )

AutoGLM_GUI/parsers/__init__.py

@@ -0,0 +1,22 @@
+"""Action parsers for different agent types.
+
+This module provides parser implementations for converting model outputs
+into standardized action dictionaries that can be executed by ActionHandler.
+
+Each agent type has its own parser implementation:
+- GLMParser: For GLM-based agents (enhanced AST parsing)
+- PhoneAgentParser: For standard PhoneAgent (basic AST parsing)
+- MAIParser: For MAI agent (XML + JSON parsing)
+"""
+
+from .base import ActionParser
+from AutoGLM_GUI.agents.glm.parser import GLMParser
+from AutoGLM_GUI.agents.mai.parser import MAIParser
+from .phone_parser import PhoneAgentParser
+
+__all__ = [
+    "ActionParser",
+    "GLMParser",
+    "MAIParser",
+    "PhoneAgentParser",
+]

AutoGLM_GUI/parsers/base.py

@@ -0,0 +1,50 @@
+"""Base protocol for action parsers.
+
+This module defines the interface that all action parsers must implement.
+"""
+
+from typing import Any, Protocol
+
+
+class ActionParser(Protocol):
+    """Protocol for parsing model outputs into action dictionaries.
+
+    All parser implementations must provide:
+    1. parse() method to convert raw model output into standardized action dict
+    2. coordinate_scale property to specify the coordinate normalization range
+
+    The standardized action dictionary format:
+    {
+        "_metadata": "do" | "finish",
+        "action": "Tap" | "Swipe" | "Type" | ...,  # Only when _metadata="do"
+        "coordinate": [x, y],  # Normalized to 0-1000 range
+        "text": "...",  # For Type action
+        ... # Other action-specific parameters
+    }
+    """
+
+    def parse(self, raw_response: str) -> dict[str, Any]:
+        """Parse raw model output into standardized action dictionary.
+
+        Args:
+            raw_response: Raw text output from the model.
+
+        Returns:
+            Standardized action dictionary with:
+            - "_metadata": "do" or "finish"
+            - "action": Action type (Tap, Swipe, etc.) when _metadata="do"
+            - Additional parameters based on action type
+
+        Raises:
+            ValueError: If the response cannot be parsed.
+        """
+        ...
+
+    @property
+    def coordinate_scale(self) -> int:
+        """Get the coordinate normalization scale used by this parser.
+
+        Returns:
+            999 for MAI parser, 1000 for GLM/PhoneAgent parsers.
+        """
+        ...

AutoGLM_GUI/parsers/phone_parser.py

@@ -0,0 +1,58 @@
+"""PhoneAgent parser using standard AST parsing."""
+
+import ast
+from typing import Any
+
+
+class PhoneAgentParser:
+    """Parse PhoneAgent function-call style outputs using ast.parse.
+
+    Handles the same format as GLM but with simpler AST-based parsing.
+    Includes special handling for Type action to avoid parsing issues.
+    Coordinate scale: 0-1000
+    """
+
+    @property
+    def coordinate_scale(self) -> int:
+        return 1000
+
+    def parse(self, raw_response: str) -> dict[str, Any]:
+        response = raw_response.strip()
+
+        if response.startswith('do(action="Type"') or response.startswith(
+            'do(action="Type_Name"'
+        ):
+            text = response.split("text=", 1)[1][1:-2]
+            action = {"_metadata": "do", "action": "Type", "text": text}
+            return action
+        elif response.startswith("do"):
+            try:
+                response = response.replace("\n", "\\n")
+                response = response.replace("\r", "\\r")
+                response = response.replace("\t", "\\t")
+
+                tree = ast.parse(response, mode="eval")
+                if not isinstance(tree.body, ast.Call):
+                    raise ValueError("Expected a function call")
+
+                call = tree.body
+                action = {"_metadata": "do"}
+                for keyword in call.keywords:
+                    key = keyword.arg
+                    if key is None:
+                        raise ValueError("Keyword argument name missing")
+                    value = ast.literal_eval(keyword.value)
+                    action[key] = value
+
+                return action
+            except (SyntaxError, ValueError) as e:
+                raise ValueError(f"Failed to parse do() action: {e}") from e
+
+        elif response.startswith("finish"):
+            action = {
+                "_metadata": "finish",
+                "message": response.replace("finish(message=", "")[1:-2],
+            }
+            return action
+        else:
+            raise ValueError(f"Failed to parse action: {response}")