isa-model 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

isa_model/inference/services/llm/helpers/llm_prompts.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+LLM通用提示词模板和工具函数
+提供标准化的提示词模板，用于不同类型的LLM任务
+"""
+
+from typing import Dict, List, Optional, Any
+import json
+
+class LLMPrompts:
+    """LLM提示词模板管理器"""
+    
+    # ==================== 对话类提示词 ====================
+    
+    @staticmethod
+    def chat_prompt(user_message: str, system_message: Optional[str] = None) -> List[Dict[str, str]]:
+        """生成标准对话提示词格式"""
+        messages = []
+        if system_message:
+            messages.append({"role": "system", "content": system_message})
+        messages.append({"role": "user", "content": user_message})
+        return messages
+    
+    @staticmethod
+    def completion_prompt(text: str, instruction: Optional[str] = None) -> str:
+        """生成文本补全提示词"""
+        if instruction:
+            return f"{instruction}\n\n{text}"
+        return text
+    
+    @staticmethod
+    def instruct_prompt(task: str, content: str, format_instruction: Optional[str] = None) -> str:
+        """生成指令跟随提示词"""
+        prompt = f"Task: {task}\n\nContent:\n{content}\n\n"
+        if format_instruction:
+            prompt += f"Output Format: {format_instruction}\n\n"
+        prompt += "Response:"
+        return prompt
+    
+    # ==================== 文本生成类提示词 ====================
+    
+    @staticmethod
+    def rewrite_prompt(text: str, style: Optional[str] = None, tone: Optional[str] = None) -> str:
+        """生成文本重写提示词"""
+        prompt = f"Please rewrite the following text"
+        if style:
+            prompt += f" in {style} style"
+        if tone:
+            prompt += f" with a {tone} tone"
+        prompt += f":\n\n{text}\n\nRewritten text:"
+        return prompt
+    
+    @staticmethod
+    def summarize_prompt(text: str, max_length: Optional[int] = None, style: Optional[str] = None) -> str:
+        """生成文本摘要提示词"""
+        prompt = f"Please summarize the following text"
+        if max_length:
+            prompt += f" in no more than {max_length} words"
+        if style:
+            prompt += f" in {style} style"
+        prompt += f":\n\n{text}\n\nSummary:"
+        return prompt
+    
+    @staticmethod
+    def translate_prompt(text: str, target_language: str, source_language: Optional[str] = None) -> str:
+        """生成翻译提示词"""
+        prompt = f"Please translate the following text"
+        if source_language:
+            prompt += f" from {source_language}"
+        prompt += f" to {target_language}:\n\n{text}\n\nTranslation:"
+        return prompt
+    
+    # ==================== 分析类提示词 ====================
+    
+    @staticmethod
+    def analyze_prompt(text: str, analysis_type: Optional[str] = None) -> str:
+        """生成文本分析提示词"""
+        if analysis_type:
+            prompt = f"Please perform {analysis_type} analysis on the following text:\n\n{text}\n\nAnalysis:"
+        else:
+            prompt = f"Please analyze the following text:\n\n{text}\n\nAnalysis:"
+        return prompt
+    
+    @staticmethod
+    def classify_prompt(text: str, categories: Optional[List[str]] = None) -> str:
+        """生成文本分类提示词"""
+        prompt = f"Please classify the following text"
+        if categories:
+            prompt += f" into one of these categories: {', '.join(categories)}"
+        prompt += f":\n\n{text}\n\nClassification:"
+        return prompt
+    
+    @staticmethod
+    def extract_prompt(text: str, extract_type: Optional[str] = None) -> str:
+        """生成信息提取提示词"""
+        if extract_type:
+            prompt = f"Please extract {extract_type} from the following text:\n\n{text}\n\nExtracted {extract_type}:"
+        else:
+            prompt = f"Please extract key information from the following text:\n\n{text}\n\nExtracted information:"
+        return prompt
+    
+    @staticmethod
+    def sentiment_prompt(text: str) -> str:
+        """生成情感分析提示词"""
+        return f"Please analyze the sentiment of the following text and classify it as positive, negative, or neutral:\n\n{text}\n\nSentiment:"
+    
+    # ==================== 编程类提示词 ====================
+    
+    @staticmethod
+    def code_generation_prompt(description: str, language: Optional[str] = None, style: Optional[str] = None) -> str:
+        """生成代码生成提示词"""
+        prompt = f"Please write code"
+        if language:
+            prompt += f" in {language}"
+        prompt += f" for the following requirement:\n\n{description}\n\n"
+        if style:
+            prompt += f"Code style: {style}\n\n"
+        prompt += "Code:"
+        return prompt
+    
+    @staticmethod
+    def code_explanation_prompt(code: str, language: Optional[str] = None) -> str:
+        """生成代码解释提示词"""
+        prompt = f"Please explain the following"
+        if language:
+            prompt += f" {language}"
+        prompt += f" code:\n\n```{language or ''}\n{code}\n```\n\nExplanation:"
+        return prompt
+    
+    @staticmethod
+    def code_debug_prompt(code: str, language: Optional[str] = None, error: Optional[str] = None) -> str:
+        """生成代码调试提示词"""
+        prompt = f"Please debug the following"
+        if language:
+            prompt += f" {language}"
+        prompt += f" code:\n\n```{language or ''}\n{code}\n```\n\n"
+        if error:
+            prompt += f"Error message: {error}\n\n"
+        prompt += "Fixed code:"
+        return prompt
+    
+    @staticmethod
+    def code_refactor_prompt(code: str, language: Optional[str] = None, improvements: Optional[List[str]] = None) -> str:
+        """生成代码重构提示词"""
+        prompt = f"Please refactor the following"
+        if language:
+            prompt += f" {language}"
+        prompt += f" code"
+        if improvements:
+            prompt += f" with these improvements: {', '.join(improvements)}"
+        prompt += f":\n\n```{language or ''}\n{code}\n```\n\nRefactored code:"
+        return prompt
+    
+    # ==================== 推理类提示词 ====================
+    
+    @staticmethod
+    def reasoning_prompt(question: str, reasoning_type: Optional[str] = None) -> str:
+        """生成推理分析提示词"""
+        if reasoning_type:
+            prompt = f"Please use {reasoning_type} reasoning to answer the following question:\n\n{question}\n\nReasoning and answer:"
+        else:
+            prompt = f"Please think step by step and answer the following question:\n\n{question}\n\nReasoning and answer:"
+        return prompt
+    
+    @staticmethod
+    def problem_solving_prompt(problem: str, problem_type: Optional[str] = None) -> str:
+        """生成问题求解提示词"""
+        prompt = f"Please solve the following"
+        if problem_type:
+            prompt += f" {problem_type}"
+        prompt += f" problem:\n\n{problem}\n\nSolution:"
+        return prompt
+    
+    @staticmethod
+    def planning_prompt(goal: str, plan_type: Optional[str] = None) -> str:
+        """生成计划制定提示词"""
+        prompt = f"Please create a"
+        if plan_type:
+            prompt += f" {plan_type}"
+        prompt += f" plan for the following goal:\n\n{goal}\n\nPlan:"
+        return prompt
+    
+    # ==================== 工具调用类提示词 ====================
+    
+    @staticmethod
+    def tool_call_prompt(query: str, available_tools: List[Dict[str, Any]]) -> str:
+        """生成工具调用提示词"""
+        tools_desc = json.dumps(available_tools, indent=2)
+        prompt = f"You have access to the following tools:\n\n{tools_desc}\n\n"
+        prompt += f"User query: {query}\n\n"
+        prompt += "Please use the appropriate tools to answer the query. Respond with tool calls in JSON format."
+        return prompt
+    
+    @staticmethod
+    def function_call_prompt(description: str, function_name: str, parameters: Dict[str, Any]) -> str:
+        """生成函数调用提示词"""
+        params_desc = json.dumps(parameters, indent=2)
+        prompt = f"Please call the function '{function_name}' with the following parameters to {description}:\n\n"
+        prompt += f"Parameters:\n{params_desc}\n\n"
+        prompt += "Function call result:"
+        return prompt
+
+class LLMPromptTemplates:
+    """预定义的提示词模板"""
+    
+    # 系统消息模板
+    SYSTEM_MESSAGES = {
+        "assistant": "You are a helpful AI assistant. Please provide accurate and helpful responses.",
+        "code_expert": "You are an expert programmer. Please provide clean, efficient, and well-documented code.",
+        "analyst": "You are a data analyst. Please provide detailed and insightful analysis.",
+        "writer": "You are a professional writer. Please provide clear, engaging, and well-structured content.",
+        "teacher": "You are a patient and knowledgeable teacher. Please explain concepts clearly and provide examples.",
+        "translator": "You are a professional translator. Please provide accurate and natural translations."
+    }
+    
+    # 输出格式模板
+    OUTPUT_FORMATS = {
+        "json": "Please format your response as valid JSON.",
+        "markdown": "Please format your response using Markdown syntax.",
+        "bullet_points": "Please format your response as bullet points.",
+        "numbered_list": "Please format your response as a numbered list.",
+        "table": "Please format your response as a table.",
+        "code": "Please format your response as code with appropriate syntax highlighting."
+    }
+    
+    # 任务特定模板
+    TASK_TEMPLATES = {
+        "email": "Please write a professional email with the following content:",
+        "report": "Please write a detailed report on the following topic:",
+        "proposal": "Please write a project proposal for the following idea:",
+        "documentation": "Please write clear documentation for the following:",
+        "test_cases": "Please write comprehensive test cases for the following:",
+        "user_story": "Please write user stories for the following feature:"
+    }
+
+def get_prompt_template(task_type: str, **kwargs) -> str:
+    """获取指定任务类型的提示词模板"""
+    prompts = LLMPrompts()
+    
+    if hasattr(prompts, f"{task_type}_prompt"):
+        method = getattr(prompts, f"{task_type}_prompt")
+        return method(**kwargs)
+    else:
+        raise ValueError(f"Unsupported task type: {task_type}")
+
+def format_messages(messages: List[Dict[str, str]], system_message: Optional[str] = None) -> List[Dict[str, str]]:
+    """格式化消息列表，添加系统消息"""
+    formatted = []
+    if system_message:
+        formatted.append({"role": "system", "content": system_message})
+    formatted.extend(messages)
+    return formatted
+
+def combine_prompts(prompts: List[str], separator: str = "\n\n") -> str:
+    """组合多个提示词"""
+    return separator.join(prompts)

isa_model/inference/services/llm/helpers/llm_utils.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+LLM工具函数和实用程序
+提供LLM服务的通用工具函数，包括文本处理、token计算、响应解析等
+"""
+
+import re
+import json
+import tiktoken
+from typing import Dict, List, Optional, Any, Union, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class TokenCounter:
+    """Token计数器"""
+    
+    def __init__(self, model_name: str = "gpt-4"):
+        """初始化token计数器"""
+        try:
+            self.encoding = tiktoken.encoding_for_model(model_name)
+        except KeyError:
+            # 如果模型不支持，使用默认编码
+            self.encoding = tiktoken.get_encoding("cl100k_base")
+    
+    def count_tokens(self, text: str) -> int:
+        """计算文本的token数量"""
+        return len(self.encoding.encode(text))
+    
+    def count_messages_tokens(self, messages: List[Dict[str, str]]) -> int:
+        """计算消息列表的总token数量"""
+        total_tokens = 0
+        for message in messages:
+            # 每个消息有固定的开销（role等）
+            total_tokens += 4  # 每个消息的基本开销
+            for key, value in message.items():
+                total_tokens += self.count_tokens(str(value))
+        total_tokens += 2  # 对话的基本开销
+        return total_tokens
+    
+    def truncate_text(self, text: str, max_tokens: int) -> str:
+        """截断文本以适应token限制"""
+        tokens = self.encoding.encode(text)
+        if len(tokens) <= max_tokens:
+            return text
+        
+        truncated_tokens = tokens[:max_tokens]
+        return self.encoding.decode(truncated_tokens)
+    
+    def split_text_by_tokens(self, text: str, chunk_size: int, overlap: int = 0) -> List[str]:
+        """按token数量分割文本"""
+        tokens = self.encoding.encode(text)
+        chunks = []
+        
+        start = 0
+        while start < len(tokens):
+            end = min(start + chunk_size, len(tokens))
+            chunk_tokens = tokens[start:end]
+            chunks.append(self.encoding.decode(chunk_tokens))
+            
+            if end >= len(tokens):
+                break
+            
+            start = end - overlap
+        
+        return chunks
+
+class TextProcessor:
+    """文本处理工具"""
+    
+    @staticmethod
+    def clean_text(text: str) -> str:
+        """清理文本，移除多余的空白字符"""
+        # 移除多余的空白字符
+        text = re.sub(r'\s+', ' ', text)
+        # 移除首尾空白
+        text = text.strip()
+        return text
+    
+    @staticmethod
+    def extract_code_blocks(text: str) -> List[Dict[str, str]]:
+        """从文本中提取代码块"""
+        code_pattern = r'```(\w+)?\n(.*?)\n```'
+        matches = re.findall(code_pattern, text, re.DOTALL)
+        
+        code_blocks = []
+        for language, code in matches:
+            code_blocks.append({
+                "language": language or "text",
+                "code": code.strip()
+            })
+        
+        return code_blocks
+    
+    @staticmethod
+    def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
+        """从文本中提取JSON"""
+        # 尝试直接解析
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+        
+        # 尝试提取JSON代码块
+        json_pattern = r'```json\n(.*?)\n```'
+        match = re.search(json_pattern, text, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                pass
+        
+        # 尝试提取花括号内容
+        brace_pattern = r'\{.*\}'
+        match = re.search(brace_pattern, text, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(0))
+            except json.JSONDecodeError:
+                pass
+        
+        return None
+    
+    @staticmethod
+    def split_into_sentences(text: str) -> List[str]:
+        """将文本分割为句子"""
+        # 简单的句子分割，基于句号、问号、感叹号
+        sentences = re.split(r'[.!?]+', text)
+        return [s.strip() for s in sentences if s.strip()]
+    
+    @staticmethod
+    def extract_entities(text: str, entity_types: List[str] = None) -> Dict[str, List[str]]:
+        """提取文本中的实体（简单版本）"""
+        entities = {}
+        
+        if not entity_types:
+            entity_types = ["email", "url", "phone", "date"]
+        
+        patterns = {
+            "email": r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
+            "url": r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',
+            "phone": r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
+            "date": r'\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b'
+        }
+        
+        for entity_type in entity_types:
+            if entity_type in patterns:
+                matches = re.findall(patterns[entity_type], text)
+                entities[entity_type] = matches
+        
+        return entities
+
+class ResponseParser:
+    """响应解析器"""
+    
+    @staticmethod
+    def parse_structured_response(response: str, expected_format: str = "json") -> Any:
+        """解析结构化响应"""
+        if expected_format == "json":
+            return TextProcessor.extract_json_from_text(response)
+        elif expected_format == "code":
+            return TextProcessor.extract_code_blocks(response)
+        else:
+            return response
+    
+    @staticmethod
+    def parse_classification_response(response: str, categories: List[str]) -> Tuple[str, float]:
+        """解析分类响应，返回类别和置信度"""
+        response_lower = response.lower()
+        
+        # 查找匹配的类别
+        for category in categories:
+            if category.lower() in response_lower:
+                # 尝试提取置信度
+                confidence_pattern = r'(\d+(?:\.\d+)?)%|confidence[:\s]*(\d+(?:\.\d+)?)'
+                match = re.search(confidence_pattern, response_lower)
+                confidence = float(match.group(1) or match.group(2)) / 100 if match else 0.8
+                return category, confidence
+        
+        # 如果没有找到匹配的类别，返回最可能的一个
+        return categories[0] if categories else "unknown", 0.5
+    
+    @staticmethod
+    def parse_sentiment_response(response: str) -> Tuple[str, float]:
+        """解析情感分析响应"""
+        response_lower = response.lower()
+        
+        # 定义情感关键词
+        sentiments = {
+            "positive": ["positive", "good", "great", "excellent", "happy", "pleased"],
+            "negative": ["negative", "bad", "terrible", "awful", "sad", "disappointed"],
+            "neutral": ["neutral", "okay", "average", "mixed", "unclear"]
+        }
+        
+        # 查找匹配的情感
+        for sentiment, keywords in sentiments.items():
+            for keyword in keywords:
+                if keyword in response_lower:
+                    # 尝试提取置信度
+                    confidence_pattern = r'(\d+(?:\.\d+)?)%|confidence[:\s]*(\d+(?:\.\d+)?)'
+                    match = re.search(confidence_pattern, response_lower)
+                    confidence = float(match.group(1) or match.group(2)) / 100 if match else 0.7
+                    return sentiment, confidence
+        
+        return "neutral", 0.5
+
+class LLMMetrics:
+    """
+    LLM性能指标计算工具
+    
+    注意：计费和使用跟踪功能已经统一到BaseService中的_track_usage()方法。
+    LLM服务应该使用BaseLLMService中的_track_llm_usage()方法来跟踪使用情况。
+    """
+    
+    @staticmethod  
+    def calculate_latency_metrics(start_time: float, end_time: float, token_count: int) -> Dict[str, float]:
+        """计算延迟指标"""
+        total_time = end_time - start_time
+        tokens_per_second = token_count / total_time if total_time > 0 else 0
+        
+        return {
+            "total_time": total_time,
+            "tokens_per_second": tokens_per_second,
+            "ms_per_token": (total_time * 1000) / token_count if token_count > 0 else 0
+        }
+    
+
+def validate_model_response(response: Any, expected_type: type = str) -> bool:
+    """验证模型响应是否符合预期类型"""
+    return isinstance(response, expected_type)
+
+def format_chat_history(messages: List[Dict[str, str]], max_history: int = 10) -> List[Dict[str, str]]:
+    """格式化聊天历史，保留最近的消息"""
+    if len(messages) <= max_history:
+        return messages
+    
+    # 保留系统消息和最近的消息
+    system_messages = [msg for msg in messages if msg.get("role") == "system"]
+    other_messages = [msg for msg in messages if msg.get("role") != "system"]
+    
+    recent_messages = other_messages[-max_history+len(system_messages):]
+    return system_messages + recent_messages
+
+def extract_function_calls(response: str) -> List[Dict[str, Any]]:
+    """从响应中提取函数调用"""
+    function_calls = []
+    
+    # 查找JSON格式的函数调用
+    json_pattern = r'\{[^{}]*"function_name"[^{}]*\}'
+    matches = re.findall(json_pattern, response)
+    
+    for match in matches:
+        try:
+            call = json.loads(match)
+            if "function_name" in call:
+                function_calls.append(call)
+        except json.JSONDecodeError:
+            continue
+    
+    return function_calls
+
+def merge_streaming_tokens(tokens: List[str]) -> str:
+    """合并流式token为完整文本"""
+    return ''.join(tokens)
+
+def detect_language(text: str) -> str:
+    """检测文本语言（简单版本）"""
+    # 简单的语言检测，基于字符模式
+    if re.search(r'[\u4e00-\u9fff]', text):
+        return "zh"
+    elif re.search(r'[а-яё]', text, re.IGNORECASE):
+        return "ru"
+    elif re.search(r'[ひらがなカタカナ]', text):
+        return "ja"
+    elif re.search(r'[가-힣]', text):
+        return "ko"
+    else:
+        return "en"