coze-coding-utils 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

coze_coding_utils/log/parser.py

@@ -1,255 +0,0 @@
-import inspect
-from dataclasses import dataclass
-from typing import Dict, Optional, Any, Callable, cast
-from langgraph.graph.state import CompiledStateGraph
-from langgraph.graph import START, END
-
-
-# return: title, description, integrations
-def extract_title_description(func_name, text: Optional[str]):
-    title = func_name
-    desc = ""
-    integrations = []
-
-    if text is None:
-        return title, desc, integrations
-
-    lines = text.strip().split('\n')
-    for line in lines:
-        if line.startswith('title'):
-            if line.startswith('title:'):
-                title = line.split('title:', 1)[1].strip()
-            if line.startswith('title：'):
-                title = line.split('title：', 1)[1].strip()
-        elif line.startswith('desc'):
-            if line.startswith('desc:'):
-                desc = line.split('desc:', 1)[1].strip()
-            if line.startswith('desc：'):
-                desc = line.split('desc：', 1)[1].strip()
-        elif line.startswith("integrations"):
-            items = ""
-            if line.startswith('integrations:'):
-                items = line.split('integrations:', 1)[1].strip()
-            if line.startswith('integrations：'):
-                items = line.split('integrations：', 1)[1].strip()
-            for item in items.split(","):
-                integrations.append(IntegrationInfo(title=item))
-
-    if title == "":
-        title = func_name
-
-    return title, desc, integrations
-
-
-@dataclass
-class SourceLocation:
-    file: str  # 节点定义源码文件路径
-    line: int  # 节点定义源码行号
-
-
-@dataclass
-class ParamInfo:
-    name: str  # 参数名
-    ptype: str  # 参数类型
-    optional: bool  # 是否选填
-    description: Optional[str] = None  # 参数说明
-    items: Optional['ParamInfo'] = None  # 子参数，用于数组
-    default: Optional[Any] = None  # 默认值，用于基础类型
-
-
-@dataclass
-class IntegrationInfo:
-    _id: str = ""  # 集成ID
-    title: str = ""  # 集成名
-    description: str = ""  # 集成描述
-
-
-@dataclass
-class NodeInfo:
-    node_id: str  # langgraph中的node_id，可能是add_node添加或节点函数名同名
-    name: str  # func name
-    title: str
-    description: str = ""
-    node_type: str = ""
-
-
-class LangGraphParser:
-    def __init__(self, app: CompiledStateGraph):
-        # 从LangGraph中获取图结构
-        self.graph_app = app
-        self.graph = app.get_graph()
-        # 从图中构建节点信息
-        self.nodes: Dict[str, NodeInfo] = {}  # NodeId -> NodeInfo
-        # 构建基础信息 - 优先使用CompiledStateGraph中的信息
-        self._build_node_info()
-        self.condition_funcs = self._pre_process_conditional_fork_node_info()  # 跟踪condition节点的判断函数，因为中间会插入哑结点和condition节点
-
-    def _is_agent_node(self, node_id: str) -> bool:
-        """
-        判断是否为Agent节点，当前是模型节点，通过add_node的metadata注入标记
-        """
-        node = self.graph.nodes.get(node_id)
-        if node and node.metadata:
-            return node.metadata.get('type', '').lower() == "agent"
-        return False
-
-    def _is_loop_node(self, node_id: str) -> bool:
-        """判断是否为循环节点"""
-        node = self.graph.nodes.get(node_id)
-        if node and node.metadata:
-            _type = node.metadata.get('type', '').lower()
-            return _type == "looparray" or _type == "loopcond"
-
-        return False
-
-    def _is_looparray_node(self, node_id: str) -> bool:
-        """判断是否为列表循环"""
-        node = self.graph.nodes.get(node_id)
-        if node and node.metadata:
-            _type = node.metadata.get('type', '').lower()
-            return _type == "looparray"
-
-        return False
-
-    def _is_loopcond_node(self, node_id: str) -> bool:
-        """判断是否为条件循环"""
-        node = self.graph.nodes.get(node_id)
-        if node and node.metadata:
-            _type = node.metadata.get('type', '').lower()
-            return _type == "loopcond"
-
-        return False
-
-    def get_node_metadata(self, func_name: str) -> dict:
-        node_id = ""
-        for _, node in self.nodes.items():
-            if node.name == func_name:
-                node_id = node.node_id
-
-        node = self.graph.nodes.get(node_id)
-        if node and node.metadata:
-            return node.metadata
-
-        return {}
-
-    def find_conditional_nodes(self):
-        conditional_nodes = set()
-        # 构建入边映射：target -> [sources]
-        incoming = {}
-        for edge in self.graph.edges:
-            incoming.setdefault(edge.target, []).append(edge.source)
-
-        # 遍历所有条件边，并将条件源映射到真实业务节点
-        for edge in self.graph.edges:
-            if getattr(edge, "conditional", False):
-                src = edge.source
-                node_obj = self.graph.nodes.get(src)
-                # 源是哑节点（编译插入，无数据函数），回溯到它的上游真实节点
-                if not node_obj or not getattr(node_obj, "data", None):
-                    for parent in incoming.get(src, []):
-                        parent_obj = self.graph.nodes.get(parent)
-                        if parent_obj and getattr(parent_obj, "data", None):
-                            conditional_nodes.add(parent)
-                else:
-                    conditional_nodes.add(src)
-        return conditional_nodes
-
-    def get_node_type(self, node_id):
-        # 简单推断逻辑
-        if node_id == START: return "start"
-        if node_id == END: return "end"
-        if self._is_loop_node(node_id): return "loop"
-        if self._is_agent_node(node_id): return "agent"
-        return "task"
-
-    def _generate_node_title(self, node_name: str) -> str:
-        """生成节点标题"""
-        if node_name == START:
-            return "开始"
-        elif node_name == END:
-            return "结束"
-        else:
-            return node_name
-
-    def _enhance_loop_node(self, canvas_node: Dict, node_info):
-        """完善循环节点定义"""
-        # 添加循环条件描述
-        canvas_node["definition"]["info"]["condition_summary"] = {}
-        # TODO: 循环条件描述暂时使用功能描述
-        if self._is_looparray_node(node_info.node_id):
-            canvas_node["definition"]["info"]["looptype"] = "looparray"
-            canvas_node["definition"]["info"]["condition_summary"]["looparray"] = node_info.description
-        else:
-            canvas_node["definition"]["info"]["looptype"] = "loopcond"
-            canvas_node["definition"]["info"]["condition_summary"]["loopcond"] = node_info.description
-
-    def _build_node_info(self):
-        """
-        构建节点参数信息
-        - 函数名
-        - 函数docstring
-        - 入参、出参
-        - 源代码路径，行号
-
-        兜底：AST不可用或解析失败，从CompiledStateGraph提取基本信息
-        """
-        self._build_node_info_by_langgraph()
-
-    def _build_node_info_by_langgraph(self):
-        for node_id, node in self.graph.nodes.items():
-            if node_id == START:
-                # 开始节点，构建工作流的入参
-                input_cls = self.graph_app.get_input_schema()
-                self.nodes[node_id] = NodeInfo(
-                    node_id=node_id,
-                    name=START,
-                    title="开始",
-                    node_type="start",
-                )
-                continue
-
-            if node_id == END:
-                # 结束节点，构建工作流的出参
-                output_cls = self.graph_app.get_output_schema()
-                self.nodes[node_id] = NodeInfo(
-                    node_id=node_id,
-                    name=END,
-                    title="结束",
-                    node_type="end",
-                )
-                continue
-
-            data = getattr(node, "data", None)
-            if data:
-                _func = getattr(data, "func", None)
-                if _func is None and callable(data):
-                    _func = cast(Callable[..., Any], data)
-                if _func is None:
-                    continue
-                node_name = _func.__name__
-                docstring = inspect.getdoc(_func)
-                title, desc, integrations = extract_title_description(node_name, docstring)
-                if node_id not in self.nodes:
-                    self.nodes[node_id] = NodeInfo(
-                        node_id=node_id,
-                        name=node_name,
-                        title=title,
-                        description=desc,
-                        node_type=self.get_node_type(node_id),
-                    )
-
-    def _pre_process_conditional_fork_node_info(self):
-        '''
-        构建条件节点的主节点信息，主要是描述，后续可扩展输入输出
-        原因：LangGraph条件判断函数不是真实节点，而就是一个普通的函数
-        '''
-
-        '''defaultdict(<class 'dict'>, {'join': {'should_continue_processing': BranchSpec(path=should_continue_processing(tags=None, recurse=True, explode_args=False, func_accepts={}), ends={'中文描述分支1': 'add_item_len', '默认分支': 'add_default_item_len'}, input_schema=<class 'graphs.state.BranchJoinInput'>)}})'''
-        branches = self.graph_app.builder.branches
-
-        conditional_funcs = {}  # parent_id: key : {"func":func,"branch_start_node":}
-        for parent_id, check in branches.items():
-            for check_func_name, spec in check.items():
-                conditional_funcs[check_func_name] = {
-                    "cond_node_name": "cond_" + parent_id} # 拼成前端的条件节点名
-        return conditional_funcs

coze_coding_utils/log/write_log.py

@@ -1,183 +0,0 @@
-import logging
-import logging.handlers
-import json
-from contextvars import ContextVar
-from typing import Optional
-from pathlib import Path
-from coze_coding_utils.runtime_ctx.context import Context
-from coze_coding_utils.log.config import LOG_DIR
-
-request_context: ContextVar[Optional[Context]] = ContextVar('request_context', default=None)
-
-
-class ContextFilter(logging.Filter):
-    
-    def filter(self, record: logging.LogRecord) -> bool:
-        ctx = request_context.get()
-        
-        if ctx:
-            record.log_id = ctx.logid or ''
-            record.run_id = ctx.run_id or ''
-            record.space_id = ctx.space_id or ''
-            record.project_id = ctx.project_id or ''
-            record.method = ctx.method or ''
-            record.x_tt_env = ctx.x_tt_env or ''
-        else:
-            record.log_id = ''
-            record.run_id = ''
-            record.space_id = ''
-            record.project_id = ''
-            record.method = ''
-            record.x_tt_env = ''
-        
-        return True
-
-
-class APSchedulerFilter(logging.Filter):
-    
-    def filter(self, record: logging.LogRecord) -> bool:
-        if record.name.startswith('apscheduler'):
-            message = record.getMessage()
-            if 'Running job' in message or 'next run at:' in message:
-                return False
-        return True
-
-
-class JsonFormatter(logging.Formatter):
-    
-    def format(self, record: logging.LogRecord) -> str:
-        log_data = {
-            'message': record.getMessage(),
-            'timestamp': self.formatTime(record, self.datefmt),
-            'level': record.levelname,
-            'logger': record.name,
-            'log_id': getattr(record, 'log_id', ''),
-            'run_id': getattr(record, 'run_id', ''),
-            'space_id': getattr(record, 'space_id', ''),
-            'project_id': getattr(record, 'project_id', ''),
-            'method': getattr(record, 'method', ''),
-            'x_tt_env': getattr(record, 'x_tt_env', ''),
-            'lineno': record.lineno,
-            'funcName': record.funcName,
-        }
-
-        if record.exc_info:
-            log_data['exc_info'] = self.formatException(record.exc_info)
-        
-        for key, value in record.__dict__.items():
-            if key not in ['name', 'msg', 'args', 'created', 'filename', 'funcName', 
-                          'levelname', 'levelno', 'lineno', 'module', 'msecs', 
-                          'message', 'pathname', 'process', 'processName', 'relativeCreated',
-                          'thread', 'threadName', 'exc_info', 'exc_text', 'stack_info',
-                          'log_id', 'run_id', 'space_id', 'project_id', 'method',
-                          'x_tt_env', 'rpc_persist_rec_rec_biz_scene', 
-                          'rpc_persist_coze_record_root_id', 'rpc_persist_rec_root_entity_type',
-                          'rpc_persist_rec_root_entity_id']:
-                log_data[key] = value
-        
-        return json.dumps(log_data, ensure_ascii=False)
-
-
-class PlainTextFormatter(logging.Formatter):
-    
-    def format(self, record: logging.LogRecord) -> str:
-        log_data = {
-            'message': record.getMessage(),
-            'timestamp': self.formatTime(record, self.datefmt),
-            'level': record.levelname,
-            'logger': record.name,
-            'log_id': getattr(record, 'log_id', ''),
-            'run_id': getattr(record, 'run_id', ''),
-            'space_id': getattr(record, 'space_id', ''),
-            'project_id': getattr(record, 'project_id', ''),
-            'method': getattr(record, 'method', ''),
-            'x_tt_env': getattr(record, 'x_tt_env', ''),
-            'lineno': record.lineno,
-            'funcName': record.funcName,
-        }
-        
-        if record.exc_info:
-            log_data['exc_info'] = self.formatException(record.exc_info)
-        
-        for key, value in record.__dict__.items():
-            if key not in ['name', 'msg', 'args', 'created', 'filename', 'funcName', 
-                          'levelname', 'levelno', 'lineno', 'module', 'msecs', 
-                          'message', 'pathname', 'process', 'processName', 'relativeCreated',
-                          'thread', 'threadName', 'exc_info', 'exc_text', 'stack_info',
-                          'log_id', 'run_id', 'space_id', 'project_id', 'method',
-                          'x_tt_env', 'rpc_persist_rec_rec_biz_scene', 
-                          'rpc_persist_coze_record_root_id', 'rpc_persist_rec_root_entity_type',
-                          'rpc_persist_rec_root_entity_id']:
-                log_data[key] = value
-        
-        return json.dumps(log_data, ensure_ascii=False)
-
-
-def setup_logging(
-    log_file: Optional[str] = None,
-    max_bytes: int = 100 * 1024 * 1024,
-    backup_count: int = 5,
-    log_level: str = "INFO",
-    use_json_format: bool = True,
-    console_output: bool = True
-):
-    
-    if log_file is None:
-        try:
-            log_dir = Path(LOG_DIR)
-            log_dir.mkdir(parents=True, exist_ok=True)
-            log_file = str(log_dir / 'app.log')
-        except Exception as e:
-            fallback_log_dir = Path('/tmp/work/logs/bypass')
-            fallback_log_dir.mkdir(parents=True, exist_ok=True)
-            log_file = str(fallback_log_dir / 'app.log')
-            print(f"Warning: Using fallback log directory: {fallback_log_dir}, due to error: {e}", flush=True)
-    
-    root_logger = logging.getLogger()
-    root_logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
-    
-    root_logger.handlers.clear()
-    
-    context_filter = ContextFilter()
-    apscheduler_filter = APSchedulerFilter()
-    
-    file_handler = logging.handlers.RotatingFileHandler(
-        filename=log_file,
-        maxBytes=max_bytes,
-        backupCount=backup_count,
-        encoding='utf-8'
-    )
-    file_handler.setLevel(getattr(logging, log_level.upper(), logging.INFO))
-    
-    if use_json_format:
-        file_formatter = JsonFormatter()
-    else:
-        file_formatter = PlainTextFormatter(
-            fmt='%(asctime)s %(levelname)s [log_id=%(log_id)s] [run_id=%(run_id)s] %(name)s:%(lineno)d %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
-    
-    file_handler.setFormatter(file_formatter)
-    file_handler.addFilter(context_filter)
-    file_handler.addFilter(apscheduler_filter)
-    root_logger.addHandler(file_handler)
-    
-    if console_output:
-        console_handler = logging.StreamHandler()
-        console_handler.setLevel(getattr(logging, log_level.upper(), logging.INFO))
-        
-        console_formatter = PlainTextFormatter(
-            fmt='%(asctime)s %(levelname)s [log_id=%(log_id)s] [run_id=%(run_id)s] %(name)s:%(lineno)d %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
-        console_handler.setFormatter(console_formatter)
-        console_handler.addFilter(context_filter)
-        console_handler.addFilter(apscheduler_filter)
-        root_logger.addHandler(console_handler)
-    
-    logging.info(f"Logging configured: file={log_file}, max_bytes={max_bytes}, backup_count={backup_count}")
-    
-    return log_file
-
-
-__all__ = ['setup_logging', 'request_context', 'ContextFilter', 'APSchedulerFilter', 'JsonFormatter', 'PlainTextFormatter']

coze_coding_utils/messages/client.py

@@ -1,48 +0,0 @@
-from dataclasses import dataclass, field
-from typing import List, Optional, Literal
-
-MESSAGE_TYPE_QUERY = "query"
-MessageType = Literal["query"]
-
-BLOCK_TYPE_TEXT = "text"
-BLOCK_TYPE_UPLOAD_FILE = "upload_file"
-
-BlockType = Literal["text", "upload_file"]
-
-
-@dataclass
-class UploadFileBlockDetail:
-    file_name: str = field(default_factory=str)
-    file_path: str = field(default_factory=str)
-    url: str = field(default_factory=str)
-
-
-@dataclass
-class PromptBlockContent:
-    text: Optional[str] = field(default=None)
-    upload_file: Optional[UploadFileBlockDetail] = field(default=None)
-
-
-@dataclass
-class PromptBlock:
-    type: BlockType = field(default_factory=str)
-    content: PromptBlockContent = field(default_factory=PromptBlockContent)
-
-
-@dataclass
-class QueryDetail:
-    prompt: List[PromptBlock] = field(default_factory=list)
-
-
-@dataclass
-class ClientMessageContent:
-    query: Optional[QueryDetail] = field(default=None)
-
-
-@dataclass
-class ClientMessage:
-    type: MessageType = field(default_factory=str)
-    project_id: str = field(default_factory=str)
-    session_id: str = field(default_factory=str)
-    local_msg_id: str = field(default_factory=str)
-    content: ClientMessageContent = field(default_factory=ClientMessageContent)

coze_coding_utils/messages/server.py

@@ -1,173 +0,0 @@
-import uuid
-from dataclasses import dataclass, field, asdict
-from typing import List, Optional, Any, Dict, Literal
-
-# Message Types
-MESSAGE_TYPE_ANSWER = "answer"
-MESSAGE_TYPE_THINKING = "thinking"
-MESSAGE_TYPE_TOOL_REQUEST = "tool_request"
-MESSAGE_TYPE_TOOL_RESPONSE = "tool_response"
-MESSAGE_TYPE_MESSAGE_START = "message_start"
-MESSAGE_TYPE_MESSAGE_END = "message_end"
-MESSAGE_TYPE_ERROR = "error"
-
-
-
-MessageType = Literal[
-    MESSAGE_TYPE_ANSWER,
-    MESSAGE_TYPE_THINKING,
-    MESSAGE_TYPE_TOOL_REQUEST,
-    MESSAGE_TYPE_TOOL_RESPONSE,
-    MESSAGE_TYPE_MESSAGE_START,
-    MESSAGE_TYPE_MESSAGE_END,
-    MESSAGE_TYPE_ERROR,
-]
-
-
-# Message End Codes
-MESSAGE_END_CODE_SUCCESS = "0"
-MESSAGE_END_CODE_CANCELED = "1"
-
-# Tool Response Codes
-TOOL_RESP_CODE_SUCCESS = "0"
-
-
-@dataclass
-class TokenCost:
-    input_tokens: int = field(default_factory=int)
-    output_tokens: int = field(default_factory=int)
-    total_tokens: int = field(default_factory=int)
-
-
-@dataclass
-class MessageEndDetail:
-    code: str = field(default_factory=str)  # 错误码
-    message: str = field(default_factory=str)  # 错误消息
-
-    token_cost: Optional[TokenCost] = field(default=None)  # 消耗的token数量
-    time_cost_ms: Optional[int] = field(default=None)  # 耗时，单位毫秒
-
-
-@dataclass
-class MessageStartDetail:
-    local_msg_id: str = field(default_factory=str)
-    msg_id: str = field(default_factory=str)
-    execute_id: str = field(default_factory=str)
-
-@dataclass
-class ErrorDetail:
-    local_msg_id: str = field(default_factory=str)
-    code: str = field(default_factory=str)  # 错误码
-    error_msg: str = field(default_factory=str)  # 错误消息
-
-@dataclass
-class ToolRequestDetail:
-    tool_call_id: str = field(default_factory=str)
-    tool_name: str = field(default_factory=str)
-    parameters: Dict[str, Any] = field(default_factory=dict)  # tool_name to parameters
-
-
-@dataclass
-class ToolResponseDetail:
-    tool_call_id: str = field(default_factory=str)
-
-    code: str = field(default_factory=str)  # 错误码
-    message: str = field(default_factory=str)  # 错误消息
-
-    result: str = field(default_factory=str)  # tool执行结果
-    time_cost_ms: Optional[int] = field(default=None)  # 耗时，单位毫秒
-
-
-@dataclass
-class ServerMessageContent:
-    answer: Optional[str] = field(default=None)  # 回答内容
-    thinking: Optional[str] = field(default=None)  # 思考内容
-    tool_request: Optional[ToolRequestDetail] = field(default=None)  # tool请求详情
-    tool_response: Optional[ToolResponseDetail] = field(default=None)  # tool响应详情
-
-    error: Optional[ErrorDetail] = field(default=None)  # 错误详情
-
-    message_start: Optional[MessageStartDetail] = field(default=None)  # 消息开始详情, 接收到消息后发送
-    message_end: Optional[MessageEndDetail] = field(default=None)      # 消息结束详情, 处理完消息后发送
-
-
-@dataclass
-class ServerMessage:
-    type: MessageType = field(default_factory=str)  # 消息类型
-    session_id: str = field(default_factory=str)  # 会话id
-    query_msg_id: str = field(default_factory=str)  # 对应的 client_msg_id
-    reply_id: str = field(default_factory=str)  # 回复id, 一次回复过程中唯一
-    msg_id: str = field(
-        default_factory=str
-    )  # 消息 id, 每个单独的消息(tool_request/tool_response等)都有一个唯一的 msg_id
-    sequence_id: int = field(default_factory=int)  # 消息在回复中的序号, 从1开始递增
-    finish: bool = field(
-        default_factory=bool
-    )  # 如果是流式消息,比如流式的 thinking,表示是否是最后一条消息
-    content: ServerMessageContent = field(
-        default_factory=ServerMessageContent
-    )  # 消息内容
-    log_id: str = field(default_factory=str)  # 日志id, 用于关联日志
-
-    def dict(self):
-        return asdict(self)
-
-
-
-def create_message_end_dict(
-    code: str,
-    message: str,
-    session_id: str,
-    query_msg_id: str,
-    log_id: str,
-    time_cost_ms: int,
-    reply_id: str = '',
-    sequence_id: int = 1,
-) -> Dict[str, Any]:
-    """创建 message_end 消息字典，复用现有的 ServerMessage 结构"""
-    return ServerMessage(
-        type=MESSAGE_TYPE_MESSAGE_END,
-        session_id=session_id,
-        query_msg_id=query_msg_id,
-        reply_id=reply_id,
-        msg_id=str(uuid.uuid4()),
-        sequence_id=sequence_id,
-        finish=True,
-        content=ServerMessageContent(
-            message_end=MessageEndDetail(
-                code=code,
-                message=message,
-                time_cost_ms=time_cost_ms,
-                token_cost=TokenCost(input_tokens=0, output_tokens=0, total_tokens=0),
-            )
-        ),
-        log_id=log_id,
-    ).dict()
-
-
-def create_message_error_dict(
-    code: str,
-    message: str,
-    session_id: str,
-    query_msg_id: str,
-    log_id: str,
-    reply_id: str = '',
-    sequence_id: int = 1,
-    local_msg_id: str = '',
-) -> Dict[str, Any]:
-    return ServerMessage(
-        type=MESSAGE_TYPE_ERROR,
-        session_id=session_id,
-        query_msg_id=query_msg_id,
-        reply_id=reply_id,
-        sequence_id=sequence_id,
-        finish=True,
-        content=ServerMessageContent(
-            error=ErrorDetail(
-                local_msg_id=local_msg_id,
-                code=code,
-                error_msg=message,
-            )
-        ),
-        log_id=log_id,
-    ).dict()

coze_coding_utils/openai/__init__.py

@@ -1,5 +0,0 @@
-"""OpenAI Chat Completions API 兼容层"""
-
-from coze_coding_utils.openai.handler import OpenAIChatHandler
-
-__all__ = ["OpenAIChatHandler"]

coze_coding_utils/openai/converter/__init__.py

@@ -1,6 +0,0 @@
-"""OpenAI 转换器"""
-
-from coze_coding_utils.openai.converter.request_converter import RequestConverter
-from coze_coding_utils.openai.converter.response_converter import ResponseConverter
-
-__all__ = ["RequestConverter", "ResponseConverter"]