vools 0.1.1__py3-none-any.whl

tests/__init__.py

@@ -0,0 +1,45 @@
+"""
+测试入口文件
+"""
+
+import sys
+import os
+
+# 添加父目录到路径
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+# 导入所有测试模块
+from .test_decorators import *
+from .test_functional import *
+from .test_utils import *
+
+
+def run_all_tests():
+    """运行所有测试"""
+    print("=" * 60)
+    print("运行 vools 测试套件")
+    print("=" * 60)
+    
+    # 装饰器测试
+    test_memorize()
+    test_once()
+    test_lazy()
+    
+    # 函数式编程测试
+    test_pipe()
+    test_ops()
+    test_seq()
+    test_p()
+    test_none()
+    
+    # 通用工具测试
+    test_basic_functions()
+    test_stuff()
+    
+    print("\n" + "=" * 60)
+    print("[SUCCESS] 所有测试通过!")
+    print("=" * 60)
+
+
+if __name__ == '__main__':
+    run_all_tests()

tests/test_curried.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+测试 curried 模块中的柯里化函数
+"""
+
+import sys
+import os
+
+# 添加父目录到路径
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from vools.decorators import (
+    curried_map, curried_filter, curried_reduce, compose, pipe, curried_pipe,
+    add, mul, sub, div,
+    and_, or_, not_,
+    identity, const, flip, apply, curried_apply
+)
+
+
+def test_higher_order_functions():
+    """测试高阶函数"""
+    print("=== 测试高阶函数 ===")
+    
+    # 测试 curried_map
+    double = lambda x: x * 2
+    assert curried_map(double, [1, 2, 3]) == [2, 4, 6]
+    assert curried_map(double)([1, 2, 3]) == [2, 4, 6]
+    print("[OK] curried_map 测试通过")
+    
+    # 测试 curried_filter
+    is_even = lambda x: x % 2 == 0
+    assert curried_filter(is_even, [1, 2, 3, 4]) == [2, 4]
+    assert curried_filter(is_even)([1, 2, 3, 4]) == [2, 4]
+    print("[OK] curried_filter 测试通过")
+    
+    # 测试 curried_reduce
+    add_func = lambda x, y: x + y
+    assert curried_reduce(add_func, [1, 2, 3]) == 6
+    assert curried_reduce(add_func)([1, 2, 3]) == 6
+    assert curried_reduce(add_func, [1, 2, 3], 10) == 16
+    print("[OK] curried_reduce 测试通过")
+    
+    # 测试 compose
+    add_one = lambda x: x + 1
+    composed = compose(add_one, double)
+    assert composed(5) == 11
+    print("[OK] compose 测试通过")
+    
+    # 测试 pipe
+    result = pipe(5, double, add_one)
+    assert result == 11
+    print("[OK] pipe 测试通过")
+    
+    # 测试 curried_pipe
+    result = curried_pipe(5, double, add_one)
+    assert result == 11
+    assert curried_pipe(5)(double, add_one) == 11
+    print("[OK] curried_pipe 测试通过")
+
+
+def test_math_functions():
+    """测试数学函数"""
+    print("\n=== 测试数学函数 ===")
+    
+    # 测试 add
+    assert add(1, 2) == 3
+    assert add(1)(2) == 3
+    print("[OK] add 测试通过")
+    
+    # 测试 mul
+    assert mul(2, 3) == 6
+    assert mul(2)(3) == 6
+    print("[OK] mul 测试通过")
+    
+    # 测试 sub
+    assert sub(5, 2) == 3
+    assert sub(5)(2) == 3
+    print("[OK] sub 测试通过")
+    
+    # 测试 div
+    assert div(6, 2) == 3.0
+    assert div(6)(2) == 3.0
+    print("[OK] div 测试通过")
+
+
+def test_logic_functions():
+    """测试逻辑函数"""
+    print("\n=== 测试逻辑函数 ===")
+    
+    # 测试 and_
+    assert and_(True, False) is False
+    assert and_(True)(True) is True
+    print("[OK] and_ 测试通过")
+    
+    # 测试 or_
+    assert or_(True, False) is True
+    assert or_(False)(False) is False
+    print("[OK] or_ 测试通过")
+    
+    # 测试 not_
+    assert not_(True) is False
+    assert not_(False) is True
+    print("[OK] not_ 测试通过")
+
+
+def test_util_functions():
+    """测试工具函数"""
+    print("\n=== 测试工具函数 ===")
+    
+    # 测试 identity
+    assert identity(5) == 5
+    assert identity("hello") == "hello"
+    print("[OK] identity 测试通过")
+    
+    # 测试 const
+    always_five = const(5)
+    assert always_five(10) == 5
+    assert const("hello", "world") == "hello"
+    print("[OK] const 测试通过")
+    
+    # 测试 flip
+    subtract = lambda a, b: a - b
+    flipped_subtract = flip(subtract)
+    assert flipped_subtract(2, 5) == 3  # 相当于 subtract(5, 2)
+    print("[OK] flip 测试通过")
+    
+    # 测试 apply
+    add_func = lambda a, b: a + b
+    assert apply(add_func, 1, 2) == 3
+    print("[OK] apply 测试通过")
+    
+    # 测试 curried_apply
+    assert curried_apply(add_func, 1, 2) == 3
+    assert curried_apply(add_func)(1, 2) == 3
+    print("[OK] curried_apply 测试通过")
+
+
+if __name__ == "__main__":
+    try:
+        test_higher_order_functions()
+        test_math_functions()
+        test_logic_functions()
+        test_util_functions()
+        print("\n[SUCCESS] 所有测试通过！")
+    except Exception as e:
+        print(f"\n[ERROR] 测试失败: {e}")
+        import traceback
+        traceback.print_exc()

tests/test_curry_overload.py

@@ -0,0 +1,181 @@
+"""测试 curry 和 overload 装饰器"""
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from vools import curry, overload, overloads
+from vools.decorators import strict,curry as curry_decorator
+
+print("=" * 60)
+print("测试 smart_partial 和 overload 装饰器")
+print("=" * 60)
+
+# 测试 smart_partial
+print("\n=== 测试 smart_partial ===")
+
+@curry_decorator
+def add(a, b, c):
+    return a + b + c
+
+result = add(1)(2)(3)
+print(f"add(1)(2)(3) = {result}")
+assert result == 6
+
+result = add(1, 2)(3)
+print(f"add(1, 2)(3) = {result}")
+assert result == 6
+
+print("[OK] smart_partial 测试通过")
+
+# 测试 overload
+print("\n=== 测试 overload ===")
+
+@overload
+def process():
+    return "无参数"
+
+@process.register
+def process(x):
+    return f"一个参数: {x}"
+
+@process.register
+def process(x, y):
+    return f"两个参数: {x}, {y}"
+
+result1 = process()
+result2 = process(10)
+result3 = process(10, 20)
+
+print(f"process() = {result1}")
+print(f"process(10) = {result2}")
+print(f"process(10, 20) = {result3}")
+
+assert result1 == "无参数"
+assert result2 == "一个参数: 10"
+assert result3 == "两个参数: 10, 20"
+
+print("[OK] overload 测试通过")
+
+# 测试 strict
+print("\n=== 测试 strict ===")
+
+@strict
+def multiply(a: int, b: int) -> int:
+    return a * b
+
+result = multiply(3, 4)
+print(f"multiply(3, 4) = {result}")
+assert result == 12
+
+try:
+    multiply(3, "4")
+    assert False, "应该抛出 TypeError"
+except TypeError as e:
+    print(f"正确捕获类型错误: {e}")
+
+print("[OK] strict 测试通过")
+
+print("\n" + "=" * 60)
+print("[SUCCESS] 所有测试通过!")
+print("=" * 60)
+
+
+
+
+def test_overloads():
+    """测试 overloads 装饰器"""
+    @overload
+    def process():
+        return "无参数"
+        
+    @process.register
+    def process(x):
+        return f"一个参数: {x}"
+    
+        
+    @process.register
+    def process(x, y):
+        return f"两个参数: {x}, {y}"
+
+    result1 = process()
+    result2 = process(10)
+    result3 = process(10, 20)
+
+    assert result1 == "无参数"
+    assert result2 == "一个参数: 10"
+    assert result3 == "两个参数: 10, 20"
+
+
+    class Test:
+        def __init__(self, a, b):
+            self.a = a
+            self.b = b
+        
+        @overload
+        def process(self):
+            return f"一个参数: {self.a}, {self.b}"
+        
+        @process.register
+        def process(self, x):
+            return f"两个参数: {self.a}, {self.b}, {x}"
+        
+        @process.register
+        def process(self, x, y):
+            return f"三个参数: {self.a}, {self.b}, {x}, {y}"
+        
+    test = Test(1, 2)
+    result1 = test.process()
+    result2 = test.process(3)
+    result3 = test.process(4, 5)
+    
+    assert result1 == "一个参数: 1, 2"
+    assert result2 == "两个参数: 1, 2, 3"
+    assert result3 == "三个参数: 1, 2, 4, 5"
+
+
+    @overload
+    def process2(x:int, y:int):
+        return f"两个参数: {x}, {y},type:{type(x)},{type(y)}"
+    
+    @process2.register
+    def process2(x:str, y:str):
+        return f"两个参数: {x}, {y},type:{type(x)},{type(y)}"
+    
+    result1 = process2(10, 20)
+    result2 = process2("10", "20")
+    # print(result1)
+    # print(result2)
+    assert result1 == "两个参数: 10, 20,type:<class 'int'>,<class 'int'>"
+    assert result2 == "两个参数: 10, 20,type:<class 'str'>,<class 'str'>"
+
+    
+
+
+
+test_overloads()
+
+
+
+def test_curry_decorator():
+    """测试 curry_decorator 装饰器"""
+    @curry_decorator
+    def process(a, b, c):
+        return a + b + c
+    
+    result = process(1)(2)(3)
+    print(f"process(1)(2)(3) = {result}")
+    assert result == 6
+
+    process.delaied = True
+
+    rs = process(1)(2)(3)
+    print(f"process(1)(2)(3) = {rs}")
+    assert rs() == 6
+
+
+    
+    print("[OK] curry_decorator 测试通过")
+
+
+test_curry_decorator()

tests/test_data.py

@@ -0,0 +1,60 @@
+"""
+数据处理工具测试
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import unittest
+from vools import data
+
+
+class TestDataModule(unittest.TestCase):
+    """数据处理模块测试"""
+
+    def test_data_available(self):
+        """测试数据模块是否可用"""
+        from vools import DATA_AVAILABLE
+        self.assertTrue(DATA_AVAILABLE)
+
+    def test_tabulate_import(self):
+        """测试 tabulate 导入"""
+        try:
+            from vools.data.tabulate import tabulate
+            self.assertIsNotNone(tabulate)
+        except ImportError:
+            self.skipTest("tabulate not available")
+
+    def test_tabulate_basic(self):
+        """测试 tabulate 基本功能"""
+        try:
+            from vools.data.tabulate import tabulate
+            table = [["Alice", 24], ["Bob", 19]]
+            headers = ["Name", "Age"]
+            result = tabulate(table, headers=headers)
+            self.assertIn("Alice", result)
+            self.assertIn("Bob", result)
+        except ImportError:
+            self.skipTest("tabulate not available")
+
+    def test_transform_import(self):
+        """测试 transform 导入"""
+        try:
+            from vools.data.transform import to_spark_df
+            self.assertIsNotNone(to_spark_df)
+        except ImportError:
+            self.skipTest("transform not available (requires pandas/pyspark)")
+
+    def test_excel_import(self):
+        """测试 excel 导入"""
+        try:
+            from vools.data.excel import write_excel, delete_obsolete_files
+            self.assertIsNotNone(write_excel)
+            self.assertIsNotNone(delete_obsolete_files)
+        except ImportError:
+            self.skipTest("excel not available (requires pandas/openpyxl)")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_datetime.py

@@ -0,0 +1,52 @@
+"""
+日期时间工具测试
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import unittest
+from vools import datetime
+
+
+class TestDatetimeModule(unittest.TestCase):
+    """日期时间模块测试"""
+
+    def test_datetime_available(self):
+        """测试日期时间模块是否可用"""
+        from vools import DATETIME_AVAILABLE
+        self.assertTrue(DATETIME_AVAILABLE)
+
+    def test_range_import(self):
+        """测试 range 导入"""
+        try:
+            from vools.datetime.range import get_date_range, parse_date_string
+            self.assertIsNotNone(get_date_range)
+            self.assertIsNotNone(parse_date_string)
+        except ImportError as e:
+            self.skipTest(f"range not available: {e}")
+
+    def test_utils_import(self):
+        """测试 utils 导入"""
+        try:
+            from vools.datetime.utils import get_recently_months, get_recently_weeks, get_recently_days
+            self.assertIsNotNone(get_recently_months)
+            self.assertIsNotNone(get_recently_weeks)
+            self.assertIsNotNone(get_recently_days)
+        except ImportError as e:
+            self.skipTest(f"utils not available: {e}")
+
+    def test_get_recently_months(self):
+        """测试 get_recently_months 功能"""
+        try:
+            from vools.datetime.utils import get_recently_months
+            result = get_recently_months("2024-01-15", 3)
+            self.assertIsInstance(result, list)
+            self.assertGreater(len(result), 0)
+        except ImportError as e:
+            self.skipTest(f"get_recently_months not available: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()