auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/text_similarity/test_text_similarity.py

@@ -0,0 +1,306 @@
+
+
+"""
+Text Similarity Module Tests
+
+测试文本相似度计算模块的各项功能。
+"""
+
+import pytest
+import sys
+import os
+
+from autocoder.common.text_similarity.text_similarity import TextSimilarity
+from autocoder.common.text_similarity.utils import compare_texts_simple, find_best_matches, analyze_text_similarity
+
+
+class TestTextSimilarity:
+    """测试 TextSimilarity 类的功能"""
+    
+    def setup_method(self):
+        """设置测试数据"""
+        # 测试目标：验证基本的文本相似度计算功能
+        self.text_a = """def hello_world():
+    print("Hello, World!")
+    return True"""
+        
+        self.text_b = """import os
+import sys
+
+def hello_world():
+    print("Hello, World!")
+    return True
+
+def goodbye_world():
+    print("Goodbye, World!")
+    return False
+
+if __name__ == "__main__":
+    hello_world()
+    goodbye_world()"""
+    
+    def test_initialization(self):
+        """测试目标：验证 TextSimilarity 类的正确初始化"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        assert similarity.text_a == self.text_a
+        assert similarity.text_b == self.text_b
+        assert similarity.m == 3  # text_a 有 3 行
+        assert similarity.n == 14  # text_b 有 14 行（包括空行）
+        assert len(similarity.lines_a) == 3
+        assert len(similarity.lines_b) == 14
+    
+    def test_split_into_lines(self):
+        """测试目标：验证文本正确分割为行"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        lines_a = similarity._split_into_lines(self.text_a)
+        expected_lines_a = [
+            'def hello_world():',
+            '    print("Hello, World!")',
+            '    return True'
+        ]
+        
+        assert lines_a == expected_lines_a
+    
+    def test_levenshtein_ratio(self):
+        """测试目标：验证莱文斯坦相似度计算的正确性"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        # 完全相同的字符串
+        ratio1 = similarity._levenshtein_ratio("hello", "hello")
+        assert ratio1 == 1.0
+        
+        # 完全不同的字符串
+        ratio2 = similarity._levenshtein_ratio("hello", "world")
+        assert 0.0 <= ratio2 <= 1.0
+        
+        # 部分相似的字符串
+        ratio3 = similarity._levenshtein_ratio("hello", "hallo")
+        assert 0.0 < ratio3 < 1.0
+    
+    def test_get_best_matching_window(self):
+        """测试目标：验证基本滑动窗口匹配功能的正确性"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        score, window = similarity.get_best_matching_window()
+        
+        # 验证返回值类型
+        assert isinstance(score, float)
+        assert isinstance(window, str)
+        
+        # 验证相似度在合理范围内
+        assert 0.0 <= score <= 1.0
+        
+        # 验证窗口长度（应该包含3行，因为text_a有3行）
+        window_lines = window.split('\n')
+        assert len(window_lines) == 3
+        
+        # 验证找到的是最相似的部分（应该包含hello_world函数）
+        assert "hello_world" in window.lower()
+    
+    def test_get_best_matching_window_all_sizes(self):
+        """测试目标：验证全窗口大小遍历匹配功能的正确性"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        score, window, info = similarity.get_best_matching_window_all_sizes()
+        
+        # 验证返回值类型
+        assert isinstance(score, float)
+        assert isinstance(window, str)
+        assert isinstance(info, dict)
+        
+        # 验证相似度在合理范围内
+        assert 0.0 <= score <= 1.0
+        
+        # 验证详细信息包含必要字段
+        required_keys = ["window_size", "start_position", "end_position", "total_windows_checked"]
+        for key in required_keys:
+            assert key in info
+        
+        # 验证检查的窗口数量是合理的
+        assert info["total_windows_checked"] > 0
+        
+        # 验证位置信息的合理性
+        assert 0 <= info["start_position"] < info["end_position"] <= similarity.n
+    
+    def test_get_similarity_matrix(self):
+        """测试目标：验证相似度矩阵计算的正确性"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        matrix = similarity.get_similarity_matrix()
+        
+        # 验证矩阵维度
+        assert len(matrix) == similarity.m  # 行数等于text_a的行数
+        for row in matrix:
+            assert len(row) == similarity.n  # 列数等于text_b的行数
+        
+        # 验证矩阵中的值都在[0,1]范围内
+        for i in range(len(matrix)):
+            for j in range(len(matrix[i])):
+                assert 0.0 <= matrix[i][j] <= 1.0
+    
+    def test_get_window_similarities(self):
+        """测试目标：验证窗口相似度列表功能的正确性"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        similarities = similarity.get_window_similarities()
+        
+        # 验证返回的是列表
+        assert isinstance(similarities, list)
+        
+        # 验证每个元素的结构
+        for item in similarities:
+            assert isinstance(item, tuple)
+            assert len(item) == 3
+            start_pos, score, window_text = item
+            
+            assert isinstance(start_pos, int)
+            assert isinstance(score, float)
+            assert isinstance(window_text, str)
+            
+            assert 0.0 <= score <= 1.0
+            assert start_pos >= 0
+        
+        # 验证结果按相似度降序排列
+        scores = [item[1] for item in similarities]
+        assert scores == sorted(scores, reverse=True)
+    
+    def test_get_statistics(self):
+        """测试目标：验证统计信息功能的正确性"""
+        similarity = TextSimilarity(self.text_a, self.text_b)
+        
+        stats = similarity.get_statistics()
+        
+        # 验证统计信息包含所有必要字段
+        required_keys = [
+            "text_a_lines", "text_b_lines", "text_a_chars", "text_b_chars",
+            "possible_windows", "full_text_similarity"
+        ]
+        for key in required_keys:
+            assert key in stats
+        
+        # 验证统计信息的正确性
+        assert stats["text_a_lines"] == 3
+        assert stats["text_b_lines"] == 14
+        assert stats["text_a_chars"] == len(self.text_a)
+        assert stats["text_b_chars"] == len(self.text_b)
+        assert stats["possible_windows"] == 12  # 14 - 3 + 1
+        assert 0.0 <= stats["full_text_similarity"] <= 1.0
+    
+    def test_edge_cases(self):
+        """测试目标：验证边界情况的处理"""
+        # 空文本测试
+        empty_similarity = TextSimilarity("", "some text")
+        score, window = empty_similarity.get_best_matching_window()
+        assert isinstance(score, float)
+        
+        # 源文本比目标文本长的情况
+        long_short_similarity = TextSimilarity("very long text here", "short")
+        score, window = long_short_similarity.get_best_matching_window()
+        assert window == "short"
+        
+        # 相同文本测试
+        same_similarity = TextSimilarity("same text", "same text")
+        score, window = same_similarity.get_best_matching_window()
+        assert score == 1.0
+        assert window == "same text"
+
+
+class TestUtils:
+    """测试工具函数"""
+    
+    def setup_method(self):
+        """设置测试数据"""
+        self.text_a = "Hello World"
+        self.text_b = "Hello Beautiful World\nGoodbye Cruel World\nHello Again"
+    
+    def test_compare_texts_simple(self):
+        """测试目标：验证简单文本比较功能的完整性"""
+        result = compare_texts_simple(self.text_a, self.text_b)
+        
+        # 验证返回结构
+        assert "basic_matching" in result
+        assert "comprehensive_matching" in result
+        assert "statistics" in result
+        
+        # 验证基本匹配结果
+        basic = result["basic_matching"]
+        assert "score" in basic
+        assert "window" in basic
+        assert isinstance(basic["score"], float)
+        assert isinstance(basic["window"], str)
+        
+        # 验证全面匹配结果
+        comprehensive = result["comprehensive_matching"]
+        assert "score" in comprehensive
+        assert "window" in comprehensive
+        assert "details" in comprehensive
+    
+    def test_find_best_matches(self):
+        """测试目标：验证最佳匹配查找功能的准确性"""
+        matches = find_best_matches(self.text_a, self.text_b, top_k=2)
+        
+        # 验证返回的匹配数量
+        assert len(matches) <= 2
+        
+        # 验证每个匹配的结构
+        for match in matches:
+            required_keys = ["rank", "start_position", "end_position", "similarity_score", "window_text"]
+            for key in required_keys:
+                assert key in match
+            
+            assert isinstance(match["similarity_score"], float)
+            assert 0.0 <= match["similarity_score"] <= 1.0
+    
+    def test_analyze_text_similarity(self):
+        """测试目标：验证全面文本相似度分析功能的完整性"""
+        analysis = analyze_text_similarity(self.text_a, self.text_b)
+        
+        # 验证分析结果包含所有必要部分
+        required_sections = [
+            "summary", "basic_matching", "comprehensive_matching", 
+            "top_matches", "statistics", "similarity_matrix_shape"
+        ]
+        for section in required_sections:
+            assert section in analysis
+        
+        # 验证摘要信息
+        summary = analysis["summary"]
+        assert "basic_best_score" in summary
+        assert "comprehensive_best_score" in summary
+        assert "improvement" in summary
+        assert "total_windows_checked" in summary
+        
+        # 验证改进值的合理性（全面搜索应该不差于基本搜索）
+        assert summary["improvement"] >= 0
+
+
+if __name__ == "__main__":
+    # 运行简单的功能验证测试
+    print("运行文本相似度模块测试...")
+    
+    # 基本功能测试
+    text_a = "def test():\n    return True"
+    text_b = "import sys\n\ndef test():\n    return True\n\ndef main():\n    test()"
+    
+    similarity = TextSimilarity(text_a, text_b)
+    
+    print("=== 基本匹配测试 ===")
+    score1, window1 = similarity.get_best_matching_window()
+    print(f"基本匹配得分: {score1:.4f}")
+    print(f"匹配窗口:\n{window1}")
+    
+    print("\n=== 全面匹配测试 ===")
+    score2, window2, info2 = similarity.get_best_matching_window_all_sizes()
+    print(f"全面匹配得分: {score2:.4f}")
+    print(f"检查窗口数: {info2['total_windows_checked']}")
+    print(f"最佳窗口大小: {info2['window_size']}")
+    print(f"匹配窗口:\n{window2}")
+    
+    print(f"\n=== 性能对比 ===")
+    print(f"得分提升: {score2 - score1:.4f}")
+    
+    print("\n测试完成！")
+
+

autocoder/common/text_similarity/text_similarity.py

@@ -0,0 +1,194 @@
+
+"""
+Text Similarity Calculation Module
+
+提供文本相似度计算功能，包括滑动窗口匹配和全窗口遍历匹配两种实现方式。
+"""
+
+from difflib import SequenceMatcher
+from typing import Tuple, List, Dict, Any
+
+
+class TextSimilarity:
+    """
+    文本相似度计算类
+    
+    用于计算两个文本之间的相似度，支持基于行的比较和滑动窗口匹配。
+    """
+    
+    def __init__(self, text_a: str, text_b: str):
+        """
+        初始化文本相似度计算器
+        
+        Args:
+            text_a: 源文本（较短的文本，用作匹配模板）
+            text_b: 目标文本（较长的文本，在其中寻找匹配窗口）
+        """
+        self.text_a = text_a
+        self.text_b = text_b
+        self.lines_a = self._split_into_lines(text_a)
+        self.lines_b = self._split_into_lines(text_b)
+        self.m = len(self.lines_a)  # 源文本行数
+        self.n = len(self.lines_b)  # 目标文本行数
+
+    def _split_into_lines(self, text: str) -> List[str]:
+        """
+        将文本分割为行
+        
+        Args:
+            text: 输入文本
+            
+        Returns:
+            文本行列表
+        """
+        return text.splitlines()
+
+    def _levenshtein_ratio(self, s1: str, s2: str) -> float:
+        """
+        计算两个字符串的莱文斯坦相似度比率
+        
+        Args:
+            s1: 第一个字符串
+            s2: 第二个字符串
+            
+        Returns:
+            相似度比率 (0.0 - 1.0)
+        """
+        return SequenceMatcher(None, s1, s2).ratio()
+
+    def get_best_matching_window(self) -> Tuple[float, str]:
+        """
+        获取最佳匹配窗口（原始实现）
+        
+        使用滑动窗口在目标文本中寻找与源文本最相似的片段。
+        窗口大小固定为源文本的行数。
+        
+        Returns:
+            Tuple[float, str]: (最佳相似度, 最佳匹配窗口的文本内容)
+        """
+        if self.m > self.n:
+            # 如果源文本比目标文本长，返回整个目标文本
+            similarity = self._levenshtein_ratio(self.text_a, self.text_b)
+            return similarity, self.text_b
+        
+        best_similarity = 0
+        best_window = []
+
+        # 滑动窗口遍历
+        for i in range(self.n - self.m + 1):
+            window_b = self.lines_b[i:i + self.m]
+            similarity = self._levenshtein_ratio("\n".join(self.lines_a), "\n".join(window_b))
+            
+            if similarity > best_similarity:
+                best_similarity = similarity
+                best_window = window_b
+
+        return best_similarity, "\n".join(best_window)
+
+    def get_best_matching_window_all_sizes(self) -> Tuple[float, str, Dict[str, Any]]:
+        """
+        获取最佳匹配窗口（遍历所有窗口大小）
+        
+        遍历所有可能的窗口大小，找到得分最高的匹配窗口。
+        这种方法更全面，但计算复杂度更高。
+        
+        Returns:
+            Tuple[float, str, Dict[str, Any]]: (最佳相似度, 最佳匹配窗口的文本内容, 详细信息)
+        """
+        best_similarity = 0
+        best_window = ""
+        best_info = {
+            "window_size": 0,
+            "start_position": 0,
+            "end_position": 0,
+            "total_windows_checked": 0
+        }
+        
+        total_windows = 0
+        
+        # 遍历所有可能的窗口大小
+        for window_size in range(1, self.n + 1):
+            # 对于每个窗口大小，遍历所有可能的起始位置
+            for start_pos in range(self.n - window_size + 1):
+                end_pos = start_pos + window_size
+                window_b = self.lines_b[start_pos:end_pos]
+                window_text = "\n".join(window_b)
+                
+                # 计算相似度
+                similarity = self._levenshtein_ratio(self.text_a, window_text)
+                total_windows += 1
+                
+                if similarity > best_similarity:
+                    best_similarity = similarity
+                    best_window = window_text
+                    best_info.update({
+                        "window_size": window_size,
+                        "start_position": start_pos,
+                        "end_position": end_pos,
+                        "total_windows_checked": total_windows
+                    })
+        
+        best_info["total_windows_checked"] = total_windows
+        return best_similarity, best_window, best_info
+
+    def get_similarity_matrix(self) -> List[List[float]]:
+        """
+        获取行级别的相似度矩阵
+        
+        计算源文本的每一行与目标文本的每一行之间的相似度。
+        
+        Returns:
+            相似度矩阵，其中 matrix[i][j] 表示源文本第i行与目标文本第j行的相似度
+        """
+        matrix = []
+        for i, line_a in enumerate(self.lines_a):
+            row = []
+            for j, line_b in enumerate(self.lines_b):
+                similarity = self._levenshtein_ratio(line_a, line_b)
+                row.append(similarity)
+            matrix.append(row)
+        return matrix
+
+    def get_window_similarities(self, window_size: int = None) -> List[Tuple[int, float, str]]:
+        """
+        获取所有窗口的相似度信息
+        
+        Args:
+            window_size: 窗口大小，如果为None则使用源文本行数
+            
+        Returns:
+            List[Tuple[int, float, str]]: (起始位置, 相似度, 窗口文本) 的列表
+        """
+        if window_size is None:
+            window_size = self.m
+            
+        if window_size > self.n:
+            window_size = self.n
+            
+        similarities = []
+        for i in range(self.n - window_size + 1):
+            window_b = self.lines_b[i:i + window_size]
+            window_text = "\n".join(window_b)
+            similarity = self._levenshtein_ratio(self.text_a, window_text)
+            similarities.append((i, similarity, window_text))
+            
+        # 按相似度降序排序
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return similarities
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        获取文本统计信息
+        
+        Returns:
+            包含各种统计信息的字典
+        """
+        return {
+            "text_a_lines": self.m,
+            "text_b_lines": self.n,
+            "text_a_chars": len(self.text_a),
+            "text_b_chars": len(self.text_b),
+            "possible_windows": max(0, self.n - self.m + 1) if self.m <= self.n else 0,
+            "full_text_similarity": self._levenshtein_ratio(self.text_a, self.text_b)
+        }
+

autocoder/common/text_similarity/utils.py

@@ -0,0 +1,125 @@
+
+"""
+Text Similarity Utilities
+
+提供文本相似度计算的辅助工具函数。
+"""
+
+from typing import List, Tuple, Dict, Any
+from .text_similarity import TextSimilarity
+
+
+def compare_texts_simple(text_a: str, text_b: str) -> Dict[str, Any]:
+    """
+    简单的文本比较函数
+    
+    Args:
+        text_a: 第一个文本
+        text_b: 第二个文本
+        
+    Returns:
+        包含比较结果的字典
+    """
+    similarity = TextSimilarity(text_a, text_b)
+    
+    # 获取基本匹配结果
+    basic_score, basic_window = similarity.get_best_matching_window()
+    
+    # 获取全面匹配结果
+    full_score, full_window, full_info = similarity.get_best_matching_window_all_sizes()
+    
+    # 获取统计信息
+    stats = similarity.get_statistics()
+    
+    return {
+        "basic_matching": {
+            "score": basic_score,
+            "window": basic_window
+        },
+        "comprehensive_matching": {
+            "score": full_score,
+            "window": full_window,
+            "details": full_info
+        },
+        "statistics": stats
+    }
+
+
+def find_best_matches(text_a: str, text_b: str, top_k: int = 5) -> List[Dict[str, Any]]:
+    """
+    查找最佳匹配的前K个结果
+    
+    Args:
+        text_a: 源文本
+        text_b: 目标文本
+        top_k: 返回前K个最佳匹配
+        
+    Returns:
+        匹配结果列表，按相似度降序排列
+    """
+    similarity = TextSimilarity(text_a, text_b)
+    window_similarities = similarity.get_window_similarities()
+    
+    results = []
+    for i, (start_pos, score, window_text) in enumerate(window_similarities[:top_k]):
+        results.append({
+            "rank": i + 1,
+            "start_position": start_pos,
+            "end_position": start_pos + similarity.m,
+            "similarity_score": score,
+            "window_text": window_text
+        })
+    
+    return results
+
+
+def analyze_text_similarity(text_a: str, text_b: str) -> Dict[str, Any]:
+    """
+    全面分析两个文本的相似度
+    
+    Args:
+        text_a: 第一个文本
+        text_b: 第二个文本
+        
+    Returns:
+        详细的相似度分析结果
+    """
+    similarity = TextSimilarity(text_a, text_b)
+    
+    # 基本信息
+    stats = similarity.get_statistics()
+    
+    # 基本窗口匹配
+    basic_score, basic_window = similarity.get_best_matching_window()
+    
+    # 全面窗口匹配
+    full_score, full_window, full_info = similarity.get_best_matching_window_all_sizes()
+    
+    # 相似度矩阵
+    matrix = similarity.get_similarity_matrix()
+    
+    # 前5个最佳匹配
+    top_matches = find_best_matches(text_a, text_b, 5)
+    
+    return {
+        "summary": {
+            "basic_best_score": basic_score,
+            "comprehensive_best_score": full_score,
+            "improvement": full_score - basic_score,
+            "total_windows_checked": full_info.get("total_windows_checked", 0)
+        },
+        "basic_matching": {
+            "score": basic_score,
+            "window": basic_window
+        },
+        "comprehensive_matching": {
+            "score": full_score,
+            "window": full_window,
+            "details": full_info
+        },
+        "top_matches": top_matches,
+        "statistics": stats,
+        "similarity_matrix_shape": (len(matrix), len(matrix[0]) if matrix else 0)
+    }
+
+

autocoder/common/todos/__init__.py

@@ -0,0 +1,61 @@
+"""
+Todos management module for AutoCoder.
+
+This module provides comprehensive todo and task management functionality
+with conversation-based storage, caching, and session management.
+"""
+
+from .exceptions import (
+    TodoManagerError,
+    TodoNotFoundError,
+    TodoListNotFoundError
+)
+
+from .models import (
+    Todo,
+    TodoList
+)
+
+from .config import TodoManagerConfig
+
+# Storage layer
+from .storage import (
+    BaseStorage,
+    FileStorage
+)
+
+# Cache layer
+from .cache import (
+    BaseCache,
+    MemoryCache,
+    CacheManager
+)
+
+# Main manager
+from .manager import TodoManager
+
+__all__ = [
+    # Main manager
+    'TodoManager',
+    
+    # Exceptions
+    'TodoManagerError',
+    'TodoNotFoundError',
+    'TodoListNotFoundError',
+    
+    # Models
+    'Todo',
+    'TodoList',
+    
+    # Configuration
+    'TodoManagerConfig',
+    
+    # Storage layer
+    'BaseStorage',
+    'FileStorage',
+    
+    # Cache layer
+    'BaseCache',
+    'MemoryCache',
+    'CacheManager'
+] 

autocoder/common/todos/cache/__init__.py

@@ -0,0 +1,16 @@
+"""
+Cache module for todo management.
+
+This module provides caching functionality for todos and todo lists,
+including memory-based caching with LRU eviction and TTL support.
+"""
+
+from .base_cache import BaseCache
+from .memory_cache import MemoryCache
+from .cache_manager import CacheManager
+
+__all__ = [
+    'BaseCache',
+    'MemoryCache',
+    'CacheManager'
+]