smartrouter 1.0.9__py3-none-any.whl

smart_router/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.9"

smart_router/classifier/__init__.py

@@ -0,0 +1,6 @@
+"""Task Classifier Module"""
+
+from .task_classifier import TaskClassifier
+from .types import ClassificationResult, get_default_classification
+
+__all__ = ["TaskClassifier", "ClassificationResult", "get_default_classification"]

smart_router/classifier/difficulty_classifier.py

@@ -0,0 +1,108 @@
+"""难度评估器 - 独立评估难度"""
+
+import re
+from typing import Dict, List, Optional, Literal
+from dataclasses import dataclass
+
+
+@dataclass
+class DifficultyResult:
+    """难度评估结果"""
+    difficulty: Literal["easy", "medium", "hard"]
+    confidence: float
+    source: str  # "rule" | "default"
+    matched_rule: Optional[str] = None
+
+
+class DifficultyClassifier:
+    """难度分类器"""
+    
+    def __init__(self, rules: List[Dict]):
+        """
+        Args:
+            rules: 难度评估规则列表
+        """
+        self.rules = sorted(rules, key=lambda x: x.get("priority", 1))
+        self.default_difficulty = "medium"
+    
+    def classify(
+        self, 
+        text: str, 
+        task_type: Optional[str] = None
+    ) -> DifficultyResult:
+        """
+        评估难度
+        
+        Args:
+            text: 用户输入文本
+            task_type: 任务类型（用于过滤特定规则）
+            
+        Returns:
+            DifficultyResult
+        """
+        if not text:
+            return DifficultyResult(
+                difficulty=self.default_difficulty,
+                confidence=0.0,
+                source="default"
+            )
+        
+        text_lower = text.lower()
+        
+        # 按优先级遍历规则
+        for rule in self.rules:
+            # 检查规则是否适用于当前任务类型
+            applies_to = rule.get("applies_to")
+            if applies_to and task_type not in applies_to:
+                continue
+            
+            condition = rule.get("condition", "")
+            
+            # 解析条件
+            if self._match_condition(text_lower, condition):
+                return DifficultyResult(
+                    difficulty=rule["difficulty"],
+                    confidence=0.8,  # 规则匹配的置信度
+                    source="rule",
+                    matched_rule=rule.get("description", condition)
+                )
+        
+        # 默认返回 medium
+        return DifficultyResult(
+            difficulty=self.default_difficulty,
+            confidence=0.5,
+            source="default"
+        )
+    
+    def _match_condition(self, text: str, condition: str) -> bool:
+        """匹配条件"""
+        condition = condition.lower()
+        
+        # 条件 1: length < N
+        if match := re.match(r'length\s*<\s*(\d+)', condition):
+            length_limit = int(match.group(1))
+            return len(text) < length_limit
+        
+        # 条件 2: length > N
+        if match := re.match(r'length\s*>\s*(\d+)', condition):
+            length_limit = int(match.group(1))
+            return len(text) > length_limit
+        
+        # 条件 3: keyword:xxx|yyy
+        if match := re.match(r'keyword:([\w\|]+)', condition):
+            keywords = match.group(1).split("|")
+            for kw in keywords:
+                if kw in text:
+                    return True
+            return False
+        
+        # 条件 4: contains:xxx|yyy
+        if match := re.match(r'contains:([\w\|]+)', condition):
+            keywords = match.group(1).split("|")
+            for kw in keywords:
+                if kw in text:
+                    return True
+            return False
+        
+        # 默认：字符串包含
+        return condition in text

smart_router/classifier/embedding_matcher.py

@@ -0,0 +1,137 @@
+"""Simple Embedding Matcher - 基于词袋的相似度匹配
+
+无需外部依赖，使用简单的词频向量和余弦相似度。
+支持中英文混合文本。
+"""
+
+import re
+import math
+from typing import Dict, List, Tuple, Optional
+
+
+class SimpleEmbeddingMatcher:
+    """简单 Embedding 匹配器
+    
+    使用 TF（词频）向量和余弦相似度进行文本匹配。
+    适合小规模的示例匹配场景。
+    """
+    
+    def __init__(self, threshold: float = 0.3):
+        """
+        Args:
+            threshold: 相似度阈值，超过此值认为匹配
+        """
+        self.threshold = threshold
+    
+    def _jaccard_similarity(self, set1: set, set2: set) -> float:
+        """计算两个集合的 Jaccard 相似度"""
+        if not set1 or not set2:
+            return 0.0
+        intersection = len(set1 & set2)
+        union = len(set1 | set2)
+        if union == 0:
+            return 0.0
+        return intersection / union
+    
+    def tokenize(self, text: str) -> List[str]:
+        """分词：支持中英文
+        
+        - 英文：按空格和标点分词
+        - 中文：按字符分词（简化处理）
+        """
+        text = text.lower().strip()
+        if not text:
+            return []
+        
+        # 提取英文单词
+        english_words = re.findall(r'[a-z]+', text)
+        
+        # 提取中文字符（过滤掉标点和空格）
+        chinese_chars = re.findall(r'[\u4e00-\u9fff]', text)
+        
+        return english_words + chinese_chars
+    
+    def compute_tf(self, tokens: List[str]) -> Dict[str, float]:
+        """计算词频（TF）向量"""
+        if not tokens:
+            return {}
+        
+        freq = {}
+        for token in tokens:
+            freq[token] = freq.get(token, 0) + 1
+        
+        # 归一化
+        total = len(tokens)
+        return {k: v / total for k, v in freq.items()}
+    
+    def cosine_similarity(self, vec1: Dict[str, float], vec2: Dict[str, float]) -> float:
+        """计算两个向量的余弦相似度"""
+        if not vec1 or not vec2:
+            return 0.0
+        
+        # 计算点积
+        dot_product = 0.0
+        for key in vec1:
+            if key in vec2:
+                dot_product += vec1[key] * vec2[key]
+        
+        # 计算模长
+        norm1 = math.sqrt(sum(v ** 2 for v in vec1.values()))
+        norm2 = math.sqrt(sum(v ** 2 for v in vec2.values()))
+        
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        
+        return dot_product / (norm1 * norm2)
+    
+    def find_best_match(
+        self,
+        text: str,
+        examples_map: Dict[str, List[str]]
+    ) -> Tuple[Optional[str], float]:
+        """找到与输入文本最相似的示例类别
+        
+        使用余弦相似度和 Jaccard 相似度的加权组合，
+        对短中文文本更鲁棒。
+        
+        Args:
+            text: 输入文本
+            examples_map: {task_type: [example1, example2, ...]}
+            
+        Returns:
+            (最佳匹配的 task_type, 相似度分数)
+            如果没有超过阈值的匹配，返回 (None, 0.0)
+        """
+        input_tokens = self.tokenize(text)
+        input_set = set(input_tokens)
+        input_vec = self.compute_tf(input_tokens)
+        
+        if not input_vec:
+            return None, 0.0
+        
+        best_type = None
+        best_score = 0.0
+        
+        for task_type, examples in examples_map.items():
+            # 计算与所有示例的最大相似度（取最佳匹配）
+            max_score = 0.0
+            for example in examples:
+                example_tokens = self.tokenize(example)
+                example_vec = self.compute_tf(example_tokens)
+                
+                if example_vec:
+                    # 组合余弦相似度和 Jaccard 相似度
+                    cos_sim = self.cosine_similarity(input_vec, example_vec)
+                    jac_sim = self._jaccard_similarity(input_set, set(example_tokens))
+                    # 加权组合：余弦相似度权重 0.6，Jaccard 权重 0.4
+                    combined = cos_sim * 0.6 + jac_sim * 0.4
+                    max_score = max(max_score, combined)
+            
+            if max_score > best_score:
+                best_score = max_score
+                best_type = task_type
+        
+        if best_score >= self.threshold:
+            return best_type, best_score
+        
+        return None, best_score

smart_router/classifier/task_classifier.py

@@ -0,0 +1,372 @@
+"""Task Classifier - 任务分类器（重构版）
+
+支持两种分类方式：
+1. L1 Keywords: 基于关键词匹配（快速、精确）
+2. L2 Embedding: 基于示例相似度匹配（模糊、泛化）
+
+分类流程：
+1. 先尝试 L1 keywords 匹配
+2. 如果未命中，尝试 L2 embedding 相似度匹配
+3. 如果仍未命中，返回默认类型
+"""
+
+import re
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+from .types import ClassificationResult, get_default_classification
+from .difficulty_classifier import DifficultyClassifier, DifficultyResult
+from .embedding_matcher import SimpleEmbeddingMatcher
+
+
+@dataclass
+class TaskTypeResult:
+    """任务类型分类结果"""
+    task_type: str
+    confidence: float
+    source: str  # "keyword" | "embedding" | "default"
+
+
+class TaskTypeClassifier:
+    """任务类型分类器（支持 Keywords + Embedding 匹配）
+    
+    基于关键词匹配和示例相似度进行任务类型分类。
+    """
+    
+    def __init__(self, task_types: Dict[str, Dict]):
+        """
+        Args:
+            task_types: {
+                task_type: {
+                    keywords: [...],      # 用于 L1 精确匹配
+                    examples: [...],      # 用于 L2 相似度匹配
+                    description: ...
+                }
+            }
+        """
+        self.task_types = task_types
+        self.default_type = "chat"
+        
+        # 构建示例映射用于 Embedding 匹配
+        self.examples_map = {
+            task_type: config.get("examples", [])
+            for task_type, config in task_types.items()
+            if config.get("examples")
+        }
+        
+        # 初始化 Embedding 匹配器（阈值 0.28 适合短中文文本）
+        self._embedding_matcher = SimpleEmbeddingMatcher(threshold=0.28)
+    
+    def classify(self, messages: List[Dict]) -> TaskTypeResult:
+        """
+        分类任务类型
+        
+        流程：
+        1. L1: 关键词匹配（快速精确）
+        2. L2: 示例相似度匹配（模糊泛化）
+        3. 默认回退
+        
+        Args:
+            messages: 消息列表
+            
+        Returns:
+            TaskTypeResult
+        """
+        # 提取用户输入
+        user_content = ""
+        for msg in messages:
+            if msg.get("role") == "user":
+                user_content += msg.get("content", "") + " "
+        user_content = user_content.strip().lower()
+        
+        if not user_content:
+            return TaskTypeResult(
+                task_type=self.default_type,
+                confidence=0.0,
+                source="default"
+            )
+        
+        # L1: 关键词匹配
+        keyword_result = self._classify_by_keywords(user_content)
+        if keyword_result is not None:
+            return keyword_result
+        
+        # L2: 示例相似度匹配
+        embedding_result = self._classify_by_embedding(user_content)
+        if embedding_result is not None:
+            return embedding_result
+        
+        # 默认返回 chat
+        return TaskTypeResult(
+            task_type=self.default_type,
+            confidence=0.0,
+            source="default"
+        )
+    
+    def _classify_by_keywords(self, text: str) -> Optional[TaskTypeResult]:
+        """L1: 基于关键词匹配"""
+        best_match = None
+        best_score = 0.0
+        
+        for task_type, config in self.task_types.items():
+            keywords = config.get("keywords", [])
+            score = self._calculate_keyword_score(text, keywords)
+            
+            if score > best_score:
+                best_score = score
+                best_match = task_type
+        
+        if best_match and best_score > 0:
+            return TaskTypeResult(
+                task_type=best_match,
+                confidence=min(best_score, 1.0),
+                source="keyword"
+            )
+        
+        return None
+    
+    def _classify_by_embedding(self, text: str) -> Optional[TaskTypeResult]:
+        """L2: 基于示例相似度匹配"""
+        if not self.examples_map:
+            return None
+        
+        task_type, score = self._embedding_matcher.find_best_match(text, self.examples_map)
+        
+        if task_type is not None:
+            return TaskTypeResult(
+                task_type=task_type,
+                confidence=min(score, 1.0),
+                source="embedding"
+            )
+        
+        return None
+    
+    def _calculate_keyword_score(self, text: str, keywords: List[str]) -> float:
+        """计算关键词匹配分数
+        
+        匹配多个关键词时给予额外奖励，以提高区分度。
+        """
+        if not keywords:
+            return 0.0
+        
+        matched = []
+        for keyword in keywords:
+            # 支持正则表达式
+            try:
+                if re.search(keyword, text, re.IGNORECASE):
+                    matched.append(keyword)
+            except re.error:
+                # 普通字符串匹配
+                if keyword.lower() in text:
+                    matched.append(keyword)
+        
+        if not matched:
+            return 0.0
+        
+        # 基础分：匹配率
+        base_score = len(matched) / len(keywords)
+        # 多关键词匹配 bonus：每多匹配一个关键词加 0.15
+        bonus = 0.15 * (len(matched) - 1)
+        
+        return base_score + bonus
+
+
+# 默认难度评估规则
+# 优先级：keyword (1) > length (2)，确保语义关键词优先于长度判断
+DEFAULT_DIFFICULTY_RULES = [
+    {
+        "condition": "keyword:复杂|详细|深入|架构|设计模式|优化|重构|性能|并发|分布式",
+        "difficulty": "hard",
+        "description": "复杂关键词",
+        "priority": 1
+    },
+    {
+        "condition": "keyword:step by step|一步步|详细步骤|完整实现|全面分析",
+        "difficulty": "hard",
+        "description": "深度分析关键词",
+        "priority": 1
+    },
+    {
+        "condition": "keyword:简单|easy|快速|简述|简短|总结一下",
+        "difficulty": "easy",
+        "description": "简单关键词",
+        "priority": 1
+    },
+    {
+        "condition": "length > 500",
+        "difficulty": "hard",
+        "description": "长文本",
+        "priority": 2
+    },
+    {
+        "condition": "length < 20",
+        "difficulty": "easy",
+        "description": "极短文本",
+        "priority": 2
+    }
+]
+
+
+class TaskClassifier:
+    """统一任务分类器（重构版）
+    
+    组合任务类型分类和动态难度评估，支持 keywords 和 examples。
+    
+    分类流程：
+    1. L1 Keywords: 基于配置中的 keywords 进行快速匹配
+    2. L2 Embedding: 基于配置中的 examples 进行相似度匹配
+    3. L3 Rules: 回退到旧的规则引擎（向后兼容）
+    """
+    
+    def __init__(
+        self,
+        rules: List[Dict],
+        embedding_config: Dict,
+        task_configs: Optional[Dict[str, Dict]] = None
+    ):
+        """
+        Args:
+            rules: 分类规则列表（向后兼容）
+            embedding_config: Embedding 配置
+            task_configs: 任务配置字典 {
+                task_type: {
+                    keywords: [...],
+                    examples: [...]
+                }
+            }
+        """
+        self.rules = rules
+        self.embedding_config = embedding_config
+        self.default_type = "chat"
+        self.default_difficulty = "medium"
+        
+        # 构建 task_types 供 TaskTypeClassifier 使用
+        task_types = {}
+        
+        if task_configs:
+            # 使用新的 task_configs（包含 keywords 和 examples）
+            for task_type, config in task_configs.items():
+                task_types[task_type] = {
+                    "keywords": config.get("keywords", []),
+                    "examples": config.get("examples", []),
+                    "description": config.get("description", "")
+                }
+        else:
+            # 向后兼容：从 rules 构建（旧行为）
+            for rule in rules:
+                task_type = rule.get("task_type", "")
+                if task_type:
+                    if task_type not in task_types:
+                        task_types[task_type] = {"keywords": [], "examples": [], "description": ""}
+                    pattern = rule.get("pattern", "")
+                    if pattern:
+                        task_types[task_type]["keywords"].append(pattern)
+        
+        self._type_classifier = TaskTypeClassifier(task_types)
+        
+        # 初始化动态难度评估器
+        self._difficulty_classifier = DifficultyClassifier(DEFAULT_DIFFICULTY_RULES)
+    
+    def classify(self, messages: List[Dict]) -> ClassificationResult:
+        """
+        分类任务
+        
+        流程：
+        1. 提取用户输入并拼接
+        2. L1/L2 任务类型分类（keywords + embedding）
+        3. 动态难度评估
+        4. 多轮对话提升难度档位
+        
+        Args:
+            messages: 消息列表
+            
+        Returns:
+            ClassificationResult
+        """
+        # 提取用户输入
+        user_content = ""
+        user_message_count = 0
+        for msg in messages:
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                if content:
+                    user_content += content + " "
+                    user_message_count += 1
+        user_content = user_content.strip().lower()
+        
+        if not user_content:
+            return get_default_classification()
+        
+        # 任务类型分类（L1 keywords / L2 embedding）
+        type_result = self._type_classifier.classify(messages)
+        task_type = type_result.task_type
+        
+        # 动态难度评估
+        difficulty_result = self._difficulty_classifier.classify(user_content, task_type=task_type)
+        difficulty = difficulty_result.difficulty
+        
+        # 多轮对话提升难度：超过 3 轮 user 消息，难度升一档
+        if user_message_count > 3:
+            difficulty = self._bump_difficulty(difficulty)
+        
+        # 计算置信度
+        confidence = type_result.confidence
+        if type_result.source == "keyword":
+            confidence = max(confidence, 0.9)
+        elif type_result.source == "embedding":
+            confidence = max(confidence, 0.6)
+        
+        # 确定 source（向后兼容）
+        # 如果任务类型已明确分类（keyword/embedding），保留其 source
+        # 只有当任务类型是默认回退且难度评估器命中了规则时，才使用 dynamic_difficulty
+        if type_result.source == "default" and difficulty_result.source == "rule":
+            source = "dynamic_difficulty"
+        else:
+            source = type_result.source
+        
+        return ClassificationResult(
+            task_type=task_type,
+            estimated_difficulty=difficulty,
+            confidence=confidence,
+            source=source
+        )
+    
+    DIFFICULTY_ORDER = ["easy", "medium", "hard", "expert"]
+
+    def _adjust_difficulty(self, difficulty: str, delta: int) -> str:
+        """按档位调整难度
+
+        Args:
+            difficulty: 当前难度
+            delta: 调整量（正数提升，负数降低）
+
+        Returns:
+            调整后的难度
+        """
+        order = self.DIFFICULTY_ORDER
+        try:
+            idx = order.index(difficulty)
+            new_idx = idx + delta
+            if 0 <= new_idx < len(order):
+                return order[new_idx]
+        except ValueError:
+            pass
+        return difficulty
+
+    def _bump_difficulty(self, difficulty: str) -> str:
+        """提升难度一档"""
+        return self._adjust_difficulty(difficulty, 1)
+
+    def _lower_difficulty(self, difficulty: str) -> str:
+        """降低难度一档"""
+        return self._adjust_difficulty(difficulty, -1)
+    
+    def _match_pattern(self, text: str, pattern: str) -> bool:
+        """匹配正则模式"""
+        try:
+            return bool(re.search(pattern, text, re.IGNORECASE))
+        except re.error:
+            return pattern.lower() in text
+
+
+__all__ = ["TaskClassifier", "TaskTypeClassifier", "TaskTypeResult"]

smart_router/classifier/types.py

@@ -0,0 +1,23 @@
+"""Classifier Types"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ClassificationResult:
+    """分类结果"""
+    task_type: str
+    estimated_difficulty: str
+    confidence: float
+    source: str
+
+
+def get_default_classification() -> ClassificationResult:
+    """获取默认分类结果"""
+    return ClassificationResult(
+        task_type="chat",
+        estimated_difficulty="medium",
+        confidence=0.0,
+        source="default"
+    )