auto-coder 0.1.398__py3-none-any.whl → 0.1.400__py3-none-any.whl

autocoder/sdk/models/messages.py

@@ -0,0 +1,209 @@
+
+
+
+"""
+Auto-Coder SDK 消息模型
+
+定义Message类和相关的消息处理功能。
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+import json
+
+from ..constants import MESSAGE_ROLES
+
+
+@dataclass
+class Message:
+    """消息数据模型"""
+    
+    role: str
+    content: str
+    timestamp: Optional[datetime] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        """初始化后处理"""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        
+        # 验证role
+        if self.role not in MESSAGE_ROLES:
+            raise ValueError(f"Invalid role: {self.role}. Must be one of: {', '.join(MESSAGE_ROLES.keys())}")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式"""
+        return {
+            "role": self.role,
+            "content": self.content,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+            "metadata": self.metadata
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        """从字典创建Message实例"""
+        timestamp = None
+        if data.get("timestamp"):
+            timestamp = datetime.fromisoformat(data["timestamp"])
+        
+        return cls(
+            role=data["role"],
+            content=data["content"],
+            timestamp=timestamp,
+            metadata=data.get("metadata", {})
+        )
+    
+    def to_json(self) -> str:
+        """转换为JSON字符串"""
+        return json.dumps(self.to_dict(), ensure_ascii=False, indent=2)
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> "Message":
+        """从JSON字符串创建Message实例"""
+        data = json.loads(json_str)
+        return cls.from_dict(data)
+    
+    def add_metadata(self, key: str, value: Any) -> None:
+        """添加元数据"""
+        self.metadata[key] = value
+    
+    def get_metadata(self, key: str, default: Any = None) -> Any:
+        """获取元数据"""
+        return self.metadata.get(key, default)
+    
+    def is_user_message(self) -> bool:
+        """判断是否为用户消息"""
+        return self.role == "user"
+    
+    def is_assistant_message(self) -> bool:
+        """判断是否为助手消息"""
+        return self.role == "assistant"
+    
+    def is_system_message(self) -> bool:
+        """判断是否为系统消息"""
+        return self.role == "system"
+    
+    def __str__(self) -> str:
+        """字符串表示"""
+        return f"Message(role={self.role}, content={self.content[:50]}...)"
+    
+    def __repr__(self) -> str:
+        """详细字符串表示"""
+        return f"Message(role='{self.role}', content='{self.content}', timestamp={self.timestamp})"
+
+
+@dataclass
+class MessageBatch:
+    """消息批次，用于处理多个消息"""
+    
+    messages: List[Message] = field(default_factory=list)
+    batch_id: Optional[str] = None
+    created_at: Optional[datetime] = None
+    
+    def __post_init__(self):
+        """初始化后处理"""
+        if self.created_at is None:
+            self.created_at = datetime.now()
+        
+        if self.batch_id is None:
+            self.batch_id = f"batch_{int(self.created_at.timestamp())}"
+    
+    def add_message(self, message: Message) -> None:
+        """添加消息"""
+        self.messages.append(message)
+    
+    def add_user_message(self, content: str, metadata: Dict[str, Any] = None) -> Message:
+        """添加用户消息"""
+        message = Message(
+            role="user",
+            content=content,
+            metadata=metadata or {}
+        )
+        self.add_message(message)
+        return message
+    
+    def add_assistant_message(self, content: str, metadata: Dict[str, Any] = None) -> Message:
+        """添加助手消息"""
+        message = Message(
+            role="assistant",
+            content=content,
+            metadata=metadata or {}
+        )
+        self.add_message(message)
+        return message
+    
+    def add_system_message(self, content: str, metadata: Dict[str, Any] = None) -> Message:
+        """添加系统消息"""
+        message = Message(
+            role="system",
+            content=content,
+            metadata=metadata or {}
+        )
+        self.add_message(message)
+        return message
+    
+    def get_messages_by_role(self, role: str) -> List[Message]:
+        """根据角色获取消息"""
+        return [msg for msg in self.messages if msg.role == role]
+    
+    def get_user_messages(self) -> List[Message]:
+        """获取用户消息"""
+        return self.get_messages_by_role("user")
+    
+    def get_assistant_messages(self) -> List[Message]:
+        """获取助手消息"""
+        return self.get_messages_by_role("assistant")
+    
+    def get_system_messages(self) -> List[Message]:
+        """获取系统消息"""
+        return self.get_messages_by_role("system")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式"""
+        return {
+            "batch_id": self.batch_id,
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+            "messages": [msg.to_dict() for msg in self.messages]
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MessageBatch":
+        """从字典创建MessageBatch实例"""
+        created_at = None
+        if data.get("created_at"):
+            created_at = datetime.fromisoformat(data["created_at"])
+        
+        messages = [Message.from_dict(msg_data) for msg_data in data.get("messages", [])]
+        
+        return cls(
+            batch_id=data.get("batch_id"),
+            created_at=created_at,
+            messages=messages
+        )
+    
+    def to_json(self) -> str:
+        """转换为JSON字符串"""
+        return json.dumps(self.to_dict(), ensure_ascii=False, indent=2)
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> "MessageBatch":
+        """从JSON字符串创建MessageBatch实例"""
+        data = json.loads(json_str)
+        return cls.from_dict(data)
+    
+    def __len__(self) -> int:
+        """返回消息数量"""
+        return len(self.messages)
+    
+    def __iter__(self):
+        """迭代消息"""
+        return iter(self.messages)
+    
+    def __getitem__(self, index: int) -> Message:
+        """根据索引获取消息"""
+        return self.messages[index]
+
+

autocoder/sdk/models/options.py

@@ -0,0 +1,196 @@
+
+
+
+"""
+Auto-Coder SDK 选项配置模型
+
+定义AutoCodeOptions类，提供完整的配置选项和验证规则。
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Union, Dict, Any
+from pathlib import Path
+import os
+
+from ..constants import (
+    DEFAULT_MAX_TURNS,
+    DEFAULT_OUTPUT_FORMAT,
+    DEFAULT_PERMISSION_MODE,
+    OUTPUT_FORMATS,
+    PERMISSION_MODES,
+    ALLOWED_TOOLS
+)
+from ..exceptions import ValidationError
+
+
+@dataclass
+class AutoCodeOptions:
+    """AutoCoder选项配置类"""
+    
+    # 基础配置
+    max_turns: int = DEFAULT_MAX_TURNS
+    system_prompt: Optional[str] = None
+    cwd: Optional[Union[str, Path]] = None
+    
+    # 工具和权限配置
+    allowed_tools: List[str] = field(default_factory=list)
+    permission_mode: str = DEFAULT_PERMISSION_MODE
+    
+    # 输出配置
+    output_format: str = DEFAULT_OUTPUT_FORMAT
+    stream: bool = False
+    
+    # 会话配置
+    session_id: Optional[str] = None
+    continue_session: bool = False  # 继续最近的对话
+    
+    # 模型配置
+    model: Optional[str] = None
+    temperature: float = 0.7
+    
+    # 高级配置
+    timeout: int = 30
+    verbose: bool = False
+    include_project_structure: bool = True
+    pr: bool = False  # 是否创建 PR
+    
+    def __post_init__(self):
+        """初始化后验证"""
+        self._normalize_values()
+        self.validate()
+    
+    def validate(self) -> None:
+        """验证配置选项"""
+        
+        # 验证max_turns（-1表示不限制）
+        if self.max_turns <= 0 and self.max_turns != -1:
+            raise ValidationError("max_turns", "must be positive integer or -1 (unlimited)")
+        
+        if self.max_turns > 100 and self.max_turns != -1:
+            raise ValidationError("max_turns", "cannot exceed 100 (unless -1 for unlimited)")
+        
+        # 验证output_format
+        if self.output_format not in OUTPUT_FORMATS:
+            raise ValidationError(
+                "output_format", 
+                f"must be one of: {', '.join(OUTPUT_FORMATS.keys())}"
+            )
+        
+        # 验证permission_mode
+        if self.permission_mode not in PERMISSION_MODES:
+            raise ValidationError(
+                "permission_mode",
+                f"must be one of: {', '.join(PERMISSION_MODES.keys())}"
+            )
+        
+        # 验证allowed_tools
+        if self.allowed_tools:
+            invalid_tools = set(self.allowed_tools) - set(ALLOWED_TOOLS)
+            if invalid_tools:
+                raise ValidationError(
+                    "allowed_tools",
+                    f"invalid tools: {', '.join(invalid_tools)}. "
+                    f"Valid tools: {', '.join(ALLOWED_TOOLS)}"
+                )
+        
+        # 验证temperature
+        if not 0.0 <= self.temperature <= 2.0:
+            raise ValidationError("temperature", "must be between 0.0 and 2.0")
+        
+        # 验证timeout
+        if self.timeout <= 0:
+            raise ValidationError("timeout", "must be positive integer")
+        
+        # 验证cwd
+        if self.cwd is not None:
+            cwd_path = Path(self.cwd)
+            if not cwd_path.exists():
+                raise ValidationError("cwd", f"directory does not exist: {self.cwd}")
+            if not cwd_path.is_dir():
+                raise ValidationError("cwd", f"path is not a directory: {self.cwd}")
+    
+    def _normalize_values(self) -> None:
+        """标准化配置值"""
+        
+        # 标准化cwd路径
+        if self.cwd is not None:
+            self.cwd = str(Path(self.cwd).resolve())
+        else:
+            self.cwd = os.getcwd()
+        
+        # 如果没有指定allowed_tools，使用默认值
+        if not self.allowed_tools:
+            self.allowed_tools = ALLOWED_TOOLS.copy()
+        
+        # 标准化字符串值
+        self.output_format = self.output_format.lower()
+        self.permission_mode = self.permission_mode.lower()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式"""
+        return {
+            "max_turns": self.max_turns,
+            "system_prompt": self.system_prompt,
+            "cwd": self.cwd,
+            "allowed_tools": self.allowed_tools,
+            "permission_mode": self.permission_mode,
+            "output_format": self.output_format,
+            "stream": self.stream,
+            "session_id": self.session_id,
+            "model": self.model,
+            "temperature": self.temperature,
+            "timeout": self.timeout,
+            "verbose": self.verbose,
+            "include_project_structure": self.include_project_structure,
+            "pr": self.pr
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AutoCodeOptions":
+        """从字典创建实例"""
+        # 过滤掉不存在的字段
+        valid_fields = {f.name for f in cls.__dataclass_fields__.values()}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+        
+        return cls(**filtered_data)
+    
+    def copy(self, **changes) -> "AutoCodeOptions":
+        """创建副本并应用更改"""
+        data = self.to_dict()
+        data.update(changes)
+        return self.from_dict(data)
+    
+    def merge(self, other: "AutoCodeOptions") -> "AutoCodeOptions":
+        """合并两个配置对象"""
+        # 创建新的配置对象，从当前对象开始
+        data = self.to_dict()
+        
+        # 只覆盖other中明确设置的值（非None且非默认值）
+        if other.max_turns != DEFAULT_MAX_TURNS:
+            data["max_turns"] = other.max_turns
+        if other.system_prompt is not None:
+            data["system_prompt"] = other.system_prompt
+        if other.output_format != DEFAULT_OUTPUT_FORMAT:
+            data["output_format"] = other.output_format
+        if other.permission_mode != DEFAULT_PERMISSION_MODE:
+            data["permission_mode"] = other.permission_mode
+        if other.model is not None:
+            data["model"] = other.model
+        if other.temperature != 0.7:
+            data["temperature"] = other.temperature
+        if other.timeout != 30:
+            data["timeout"] = other.timeout
+        if other.verbose is not False:
+            data["verbose"] = other.verbose
+        if other.stream is not False:
+            data["stream"] = other.stream
+        if other.include_project_structure is not True:
+            data["include_project_structure"] = other.include_project_structure
+        if other.session_id is not None:
+            data["session_id"] = other.session_id
+        if other.allowed_tools != []:
+            data["allowed_tools"] = other.allowed_tools
+        
+        return self.from_dict(data)
+
+