jit-utils-backend 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

jit_utils/__init__.py

@@ -12,141 +12,13 @@ A comprehensive utility package for backend development with JIT.
 - 网络工具
 - 签名工具
 等等...
+
+使用方法:
+    from jit_utils.string import randomString
+    from jit_utils.time import now
+    from jit_utils.qrcode import Qrcode
+    ...
 """
 
-__version__ = '0.0.1'
+__version__ = '0.0.3'
 __author__ = 'zangtao'
-
-# 导入主要的工具类和函数
-try:
-    from .decorator import forward
-except ImportError:
-    pass
-
-# 时间工具
-try:
-    from . import time as time_utils
-    # 导出一些常用的时间函数
-    from .time import (
-        now, today, get, dayShift,
-        monday, weekShift, monthStart, monthShift,
-        quarterStart, quarterShift, yearStart, yearShift,
-        getTimestamp, timeStampToDateTime, strToTimestamp,
-        formatNow, datetime2string, string2datetime
-    )
-except ImportError:
-    pass
-
-# 字符串工具
-try:
-    from . import string as string_utils
-    from .string import (
-        randomString, randomNum, getUuidStr,
-        md5Bytes, md5Str, getFileMd5,
-        renderTemplateString
-    )
-except ImportError:
-    pass
-
-# 二维码工具
-try:
-    from .qrcode import Qrcode
-except ImportError:
-    Qrcode = None
-
-# 条形码工具
-try:
-    from .barcode import Barcode
-except ImportError:
-    Barcode = None
-
-# 验证工具
-try:
-    from .validator import ParamsValidator
-except ImportError:
-    ParamsValidator = None
-
-# 网络工具
-try:
-    from . import network
-except ImportError:
-    pass
-
-# 签名工具
-try:
-    from . import signature
-except ImportError:
-    pass
-
-# 匹配工具
-try:
-    from . import matchTool
-except ImportError:
-    pass
-
-# 类工具
-try:
-    from . import clsTool
-except ImportError:
-    pass
-
-# 转换工具
-try:
-    from .convert import Converter, MemoryCompiler
-except ImportError:
-    # 如果导入失败，创建占位符避免 __all__ 报错
-    Converter = None
-    MemoryCompiler = None
-
-# 异常处理
-try:
-    from . import exceptions
-except ImportError:
-    pass
-
-# 工作日常量
-try:
-    from . import workday_constants
-except ImportError:
-    pass
-
-# 配置相关
-try:
-    from . import config
-except ImportError:
-    pass
-
-# 定义 __all__ 列表，控制 from jit_utils import * 的行为
-__all__ = [
-    # 版本信息
-    '__version__',
-    '__author__',
-    
-    # 装饰器
-    'forward',
-    
-    # 时间工具
-    'time_utils',
-    'now', 'today', 'get', 'dayShift',
-    'monday', 'weekShift', 'monthStart', 'monthShift',
-    'quarterStart', 'quarterShift', 'yearStart', 'yearShift',
-    'getTimestamp', 'timeStampToDateTime', 'strToTimestamp',
-    'formatNow', 'datetime2string', 'string2datetime',
-    
-    # 字符串工具
-    'string_utils',
-    'randomString', 'randomNum', 'getUuidStr',
-    'md5Bytes', 'md5Str', 'getFileMd5',
-    'renderTemplateString',
-    
-    # 二维码和条形码
-    'Qrcode', 'Barcode',
-    
-    # 验证工具
-    'ParamsValidator',
-    
-    # 其他模块
-    'network', 'signature', 'matchTool',
-    'clsTool', 'exceptions', 'workday_constants',
-    'config', 'Converter', 'MemoryCompiler'
-]

{jit_utils_backend-0.0.1.dist-info → jit_utils_backend-0.0.3.dist-info}/METADATA

@@ -1,12 +1,9 @@
 Metadata-Version: 2.1
 Name: jit-utils-backend
-Version: 0.0.1
+Version: 0.0.3
 Summary: 极态后端工具包
-Author: zangtao
-Author-email: noguchisyou123456@gmail.com
-Project-URL: Documentation, https://github.com/zangtao/jit-utils-backend
-Project-URL: Source, https://github.com/zangtao/jit-utils-backend
-Project-URL: Tracker, https://github.com/zangtao/jit-utils-backend/issues
+Author: JitAi
+Author-email: develop@wanyunapp.com
 Keywords: python,jit,sdk,apiAuth,utils,backend
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -36,7 +33,7 @@ Requires-Dist: Pillow
 ## 安装
 
 ```bash
-pip install jit-utils-backend
+pip install jit_utils_backend
 ```
 
 ## 使用方法
@@ -47,11 +44,15 @@ pip install jit-utils-backend
 # 导入整个包
 import jit_utils
 
-# 导入特定功能
-from jit_utils import now, randomString, Qrcode, Barcode
+# 导入特定功能（从具体的子模块）
+from jit_utils.time import now
+from jit_utils.string import randomString
+from jit_utils.qrcode import Qrcode
+from jit_utils.barcode import Barcode
 
 # 导入特定模块
-from jit_utils import time_utils, string_utils
+import jit_utils.time
+import jit_utils.string
 ```
 
 ## 主要功能
@@ -59,7 +60,7 @@ from jit_utils import time_utils, string_utils
 ### 1. 时间处理工具
 
 ```python
-from jit_utils import now, today, dayShift, formatNow
+from jit_utils.time import now, today, dayShift, formatNow
 
 # 获取当前时间
 current_time = now()
@@ -77,7 +78,7 @@ formatted_time = formatNow("%Y-%m-%d %H:%M:%S")
 ### 2. 字符串处理工具
 
 ```python
-from jit_utils import randomString, md5Str, getUuidStr
+from jit_utils.string import randomString, md5Str, getUuidStr
 
 # 生成随机字符串
 random_str = randomString(8)
@@ -92,7 +93,7 @@ uuid_str = getUuidStr()
 ### 3. 二维码生成
 
 ```python
-from jit_utils import Qrcode
+from jit_utils.qrcode import Qrcode
 
 # 创建二维码
 qr = Qrcode("https://example.com")
@@ -107,7 +108,7 @@ qr_str = qr.toStr()
 ### 4. 条形码生成
 
 ```python
-from jit_utils import Barcode
+from jit_utils.barcode import Barcode
 
 # 创建条形码
 barcode = Barcode("123456789")
@@ -122,7 +123,7 @@ barcode_str = barcode.toStr()
 ### 5. 数据验证
 
 ```python
-from jit_utils import ParamsValidator
+from jit_utils.validator import ParamsValidator
 from dataclasses import dataclass
 
 @dataclass
@@ -138,7 +139,7 @@ params = UserParams("test_function", name="John", age=25)
 ### 6. 装饰器
 
 ```python
-from jit_utils import forward
+from jit_utils.decorator import forward
 
 @forward("module.submodule")
 def my_function():
@@ -179,4 +180,4 @@ zangtao (noguchisyou123456@gmail.com)
 
 ## 版本
 
-0.0.1
+0.0.3

{jit_utils_backend-0.0.1.dist-info → jit_utils_backend-0.0.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-jit_utils/__init__.py,sha256=l1RBpnIRE1iEATvcgT6Trpbb6qG-3g6E87sK41i6nro,3050
+jit_utils/__init__.py,sha256=uiOH1XdTzqKkXJZ0B5RbTZzJCP0Yvl5l48Lu2rmIRH8,473
 jit_utils/apiAuthSign.py,sha256=TzYe3tDVQw0LYcE82IPcibtt_qyGTJ3XbWVjti5lGx0,2323
 jit_utils/barcode.py,sha256=PuSHqxttr4rOGMAfojK7Ii72z4CoqxUQR_hmMOaElN8,1102
 jit_utils/clsTool.py,sha256=tfMy3ITwfbfBLE6cjTrrRwMWB0aFh4fAYGJBZJ3vmCE,2316
@@ -20,13 +20,7 @@ jit_utils/config/case.py,sha256=sFs5NvFaga7lbjlSDRwMKkufiIEYFSYSG3ha8PB1-58,2591
 jit_utils/config/config.py,sha256=kH0u0eTwQR0shS0KwYd9f8c9uDxKPyjxYpYQ0rKZLXc,2713
 jit_utils/config/exception.py,sha256=wrok-q14bTl8afClYgX649F2Qk0vrwl6LiWGgpkKDY0,378
 jit_utils/config/field.py,sha256=5cq0M7zAtJrFkEHQ2H-1x95ypQxMyg07JjHnIAzSPQg,4759
-tests/__init__.py,sha256=Feh5oxeLX-QAsWdK7XteVUZkQR1uZMfByvrB-Em0FEk,60
-tests/run_tests.py,sha256=_0YG9MQCLkl18U-y-3BoI_KVbCZyGhMyPtLrOygAwVw,2959
-tests/test_package_imports.py,sha256=gOn0H5LqxZ8B5jiNV23i9r2tZB4dJBEQf84V7LjVsq4,7704
-tests/test_qrcode_barcode.py,sha256=RD08MCLHap0tb8hiXyrlkkdnK6t1Ij0p6gdCrJWqCIg,6598
-tests/test_string_utils.py,sha256=i1Q98PwMrPbjc4nkb1O3Z4pwvu0SMZrSOYbgDdeU4D4,5845
-tests/test_time_utils.py,sha256=nl9k_g0HmILHYTANMMRQgOF_vO4qGkfMzs6XiEJEnYA,6944
-jit_utils_backend-0.0.1.dist-info/METADATA,sha256=IxlSo4XAQFTsE_yUsITSozIWWFqmSwLHTfqH1eDLpAE,3768
-jit_utils_backend-0.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-jit_utils_backend-0.0.1.dist-info/top_level.txt,sha256=SvmeRMPwBF2UwUtkhHAzXWSPhwVATqN2FFmZp2pJHjA,16
-jit_utils_backend-0.0.1.dist-info/RECORD,,
+jit_utils_backend-0.0.3.dist-info/METADATA,sha256=_O6Fe1jHYjVuDRmariTZttqI0tH9ul_DEClQRIJSwAI,3710
+jit_utils_backend-0.0.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+jit_utils_backend-0.0.3.dist-info/top_level.txt,sha256=r9DXZkwpqwiisjnpeWfLj01h_M6yxlF_DvjprlPJmco,10
+jit_utils_backend-0.0.3.dist-info/RECORD,,

{jit_utils_backend-0.0.1.dist-info → jit_utils_backend-0.0.3.dist-info}/top_level.txt

@@ -1,2 +1 @@
 jit_utils
-tests

tests/__init__.py

@@ -1,4 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-JIT Utils Backend 测试套件
-""" 

tests/run_tests.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-# -*-coding:utf-8-*-
-"""
-JIT Utils Backend 测试运行器
-
-运行所有测试并生成报告
-"""
-import sys
-import unittest
-import os
-
-# 添加项目根目录到Python路径
-project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, project_root)
-
-
-def run_all_tests():
-    """运行所有测试"""
-    # 发现测试目录中的所有测试
-    test_dir = os.path.dirname(os.path.abspath(__file__))
-    
-    # 创建测试套件
-    loader = unittest.TestLoader()
-    suite = loader.discover(test_dir, pattern='test_*.py')
-    
-    # 运行测试
-    runner = unittest.TextTestRunner(verbosity=2, stream=sys.stdout)
-    result = runner.run(suite)
-    
-    # 打印总结
-    print("\n" + "="*60)
-    print("测试总结:")
-    print(f"运行测试数: {result.testsRun}")
-    print(f"失败数: {len(result.failures)}")
-    print(f"错误数: {len(result.errors)}")
-    print(f"跳过数: {len(result.skipped)}")
-    
-    if result.failures:
-        print("\n失败的测试:")
-        for test, traceback in result.failures:
-            print(f"  - {test}: {traceback.split('AssertionError:')[-1].strip()}")
-    
-    if result.errors:
-        print("\n出错的测试:")
-        for test, traceback in result.errors:
-            print(f"  - {test}: {traceback.split('Error:')[-1].strip()}")
-    
-    if result.skipped:
-        print("\n跳过的测试:")
-        for test, reason in result.skipped:
-            print(f"  - {test}: {reason}")
-    
-    success_rate = ((result.testsRun - len(result.failures) - len(result.errors)) / result.testsRun * 100) if result.testsRun > 0 else 0
-    print(f"\n成功率: {success_rate:.1f}%")
-    
-    return result.wasSuccessful()
-
-
-def run_specific_test(test_name):
-    """运行特定的测试模块"""
-    test_dir = os.path.dirname(os.path.abspath(__file__))
-    
-    try:
-        # 动态导入测试模块
-        test_module = __import__(f'tests.{test_name}', fromlist=[test_name])
-        
-        # 创建测试套件
-        loader = unittest.TestLoader()
-        suite = loader.loadTestsFromModule(test_module)
-        
-        # 运行测试
-        runner = unittest.TextTestRunner(verbosity=2)
-        result = runner.run(suite)
-        
-        return result.wasSuccessful()
-        
-    except ImportError as e:
-        print(f"无法导入测试模块 '{test_name}': {e}")
-        return False
-
-
-def main():
-    """主函数"""
-    if len(sys.argv) > 1:
-        # 运行特定测试
-        test_name = sys.argv[1]
-        if not test_name.startswith('test_'):
-            test_name = f'test_{test_name}'
-        
-        print(f"运行测试模块: {test_name}")
-        success = run_specific_test(test_name)
-    else:
-        # 运行所有测试
-        print("运行所有测试...")
-        success = run_all_tests()
-    
-    # 根据测试结果设置退出码
-    sys.exit(0 if success else 1)
-
-
-if __name__ == '__main__':
-    main() 

tests/test_package_imports.py

@@ -1,199 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试包的导入功能
-"""
-import unittest
-
-
-class TestPackageImports(unittest.TestCase):
-    """包导入测试类"""
-    
-    def test_main_package_import(self):
-        """测试主包导入"""
-        try:
-            import jit_utils
-            self.assertTrue(hasattr(jit_utils, '__version__'))
-            self.assertTrue(hasattr(jit_utils, '__author__'))
-            self.assertEqual(jit_utils.__version__, '0.0.1')
-            self.assertEqual(jit_utils.__author__, 'zangtao')
-        except ImportError as e:
-            self.fail(f"主包导入失败: {e}")
-    
-    def test_string_functions_import(self):
-        """测试字符串函数导入"""
-        try:
-            from jit_utils import randomString, getUuidStr, md5Str
-            
-            # 测试函数是否可调用
-            self.assertTrue(callable(randomString))
-            self.assertTrue(callable(getUuidStr))
-            self.assertTrue(callable(md5Str))
-            
-            # 简单功能测试
-            random_str = randomString(6)
-            self.assertEqual(len(random_str), 6)
-            
-            uuid_str = getUuidStr()
-            self.assertEqual(len(uuid_str), 32)
-            
-            md5_hash = md5Str("test")
-            self.assertEqual(len(md5_hash), 32)
-            
-        except ImportError as e:
-            self.fail(f"字符串函数导入失败: {e}")
-    
-    def test_qrcode_barcode_import(self):
-        """测试二维码和条形码类导入"""
-        try:
-            from jit_utils import Qrcode, Barcode
-            
-            # 如果因为依赖问题导入为 None，跳过测试
-            if Qrcode is None or Barcode is None:
-                self.skipTest("二维码/条形码类因依赖问题不可用")
-            
-            # 测试类是否可实例化
-            self.assertTrue(callable(Qrcode))
-            self.assertTrue(callable(Barcode))
-            
-            # 创建实例
-            qr = Qrcode("test")
-            bc = Barcode("123456789")
-            
-            self.assertEqual(qr.value, "test")
-            self.assertEqual(bc.value, "123456789")
-            
-        except ImportError as e:
-            self.skipTest(f"二维码/条形码类导入失败（可能缺少依赖）: {e}")
-    
-    def test_module_imports(self):
-        """测试模块级导入"""
-        try:
-            from jit_utils import string_utils
-            self.assertTrue(hasattr(string_utils, 'randomString'))
-            self.assertTrue(hasattr(string_utils, 'md5Str'))
-        except ImportError as e:
-            self.fail(f"string_utils 模块导入失败: {e}")
-        
-        # 时间模块可能有依赖问题
-        try:
-            from jit_utils import time_utils
-            # 如果导入成功，测试一些基本属性
-            self.assertTrue(hasattr(time_utils, 'getTimestamp'))
-        except ImportError as e:
-            self.skipTest(f"time_utils 模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_network_module_import(self):
-        """测试网络模块导入"""
-        try:
-            from jit_utils import network
-            # 网络模块应该可以导入
-            self.assertIsNotNone(network)
-        except ImportError as e:
-            self.skipTest(f"network 模块导入失败: {e}")
-    
-    def test_signature_module_import(self):
-        """测试签名模块导入"""
-        try:
-            from jit_utils import signature
-            self.assertIsNotNone(signature)
-        except ImportError as e:
-            self.skipTest(f"signature 模块导入失败: {e}")
-    
-    def test_validator_import(self):
-        """测试验证器导入"""
-        try:
-            from jit_utils import ParamsValidator
-            if ParamsValidator is None:
-                self.skipTest("ParamsValidator 因依赖问题不可用")
-            self.assertTrue(callable(ParamsValidator))
-        except ImportError as e:
-            self.skipTest(f"ParamsValidator 导入失败（可能缺少依赖）: {e}")
-    
-    def test_exceptions_module_import(self):
-        """测试异常模块导入"""
-        try:
-            from jit_utils import exceptions
-            self.assertIsNotNone(exceptions)
-        except ImportError as e:
-            self.skipTest(f"exceptions 模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_config_module_import(self):
-        """测试配置模块导入"""
-        try:
-            from jit_utils import config
-            self.assertIsNotNone(config)
-        except ImportError as e:
-            self.skipTest(f"config 模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_workday_constants_import(self):
-        """测试工作日常量导入"""
-        try:
-            from jit_utils import workday_constants
-            self.assertIsNotNone(workday_constants)
-            # 检查是否有工作日相关的常量
-            self.assertTrue(hasattr(workday_constants, 'holidayDict') or 
-                          hasattr(workday_constants, 'workdayDict'))
-        except ImportError as e:
-            self.skipTest(f"workday_constants 模块导入失败: {e}")
-    
-    def test_decorator_import(self):
-        """测试装饰器导入"""
-        try:
-            from jit_utils import forward
-            self.assertTrue(callable(forward))
-        except ImportError as e:
-            self.skipTest(f"forward 装饰器导入失败（可能缺少依赖）: {e}")
-    
-    def test_convert_classes_import(self):
-        """测试转换器类导入"""
-        try:
-            from jit_utils import Converter, MemoryCompiler
-            if Converter is None or MemoryCompiler is None:
-                self.skipTest("转换器类因依赖问题不可用")
-            self.assertTrue(callable(Converter))
-            self.assertTrue(callable(MemoryCompiler))
-        except ImportError as e:
-            self.skipTest(f"转换器类导入失败（可能缺少依赖）: {e}")
-    
-    def test_all_exports(self):
-        """测试 __all__ 导出列表"""
-        import jit_utils
-        
-        # 检查 __all__ 是否存在
-        self.assertTrue(hasattr(jit_utils, '__all__'))
-        all_exports = jit_utils.__all__
-        self.assertIsInstance(all_exports, list)
-        self.assertGreater(len(all_exports), 0)
-        
-        # 检查一些关键导出
-        expected_exports = [
-            '__version__', '__author__', 'randomString', 'md5Str', 
-            'getUuidStr'
-        ]
-        
-        for export in expected_exports:
-            if export in all_exports:
-                self.assertTrue(hasattr(jit_utils, export), f"包中缺少导出: {export}")
-        
-        # 检查可能为 None 的导出（因为依赖问题）
-        optional_exports = ['Qrcode', 'Barcode', 'ParamsValidator', 'Converter', 'MemoryCompiler']
-        for export in optional_exports:
-            if export in all_exports:
-                # 这些可能因为依赖问题为 None，只要存在就行
-                self.assertTrue(hasattr(jit_utils, export), f"包中缺少可选导出: {export}")
-    
-    def test_star_import(self):
-        """测试 from jit_utils import * 是否正常工作"""
-        # 由于 * 导入会污染命名空间，我们在这里只测试是否会出错
-        try:
-            exec("from jit_utils import *")
-            # 如果执行到这里说明没有导入错误
-            self.assertTrue(True)
-        except ImportError as e:
-            self.skipTest(f"星号导入失败（可能缺少依赖）: {e}")
-        except Exception as e:
-            self.fail(f"星号导入出现意外错误: {e}")
-
-
-if __name__ == '__main__':
-    unittest.main() 

tests/test_qrcode_barcode.py

@@ -1,182 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试二维码和条形码模块
-"""
-import unittest
-import base64
-import re
-
-
-class TestQrcodeBarcode(unittest.TestCase):
-    """二维码和条形码测试类"""
-    
-    def setUp(self):
-        """测试设置"""
-        try:
-            from jit_utils.qrcode import Qrcode
-            from jit_utils.barcode import Barcode
-            self.qrcode_available = True
-            self.barcode_available = True
-            self.Qrcode = Qrcode
-            self.Barcode = Barcode
-        except ImportError as e:
-            self.qrcode_available = False
-            self.barcode_available = False
-            self.import_error = str(e)
-    
-    def test_qrcode_creation(self):
-        """测试二维码创建"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        # 创建二维码
-        qr = self.Qrcode("Hello World")
-        self.assertEqual(qr.value, "Hello World")
-        self.assertEqual(qr.row, 200)  # 默认行数
-        self.assertEqual(qr.col, 200)  # 默认列数
-        
-        # 自定义尺寸
-        qr_custom = self.Qrcode("Test", row=300, col=300)
-        self.assertEqual(qr_custom.row, 300)
-        self.assertEqual(qr_custom.col, 300)
-    
-    def test_qrcode_toByte(self):
-        """测试二维码转字节"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        qr = self.Qrcode("Hello World")
-        try:
-            byte_data = qr.toByte()
-            self.assertIsInstance(byte_data, bytes)
-            self.assertGreater(len(byte_data), 0)
-        except Exception as e:
-            self.skipTest(f"二维码生成失败: {str(e)}")
-    
-    def test_qrcode_toStr(self):
-        """测试二维码转base64字符串"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        # 测试正常值
-        qr = self.Qrcode("Hello World")
-        try:
-            str_data = qr.toStr()
-            self.assertIsInstance(str_data, str)
-            self.assertTrue(str_data.startswith("<image:"))
-            self.assertTrue(str_data.endswith(">"))
-            
-            # 提取base64部分
-            base64_part = str_data[7:-1]  # 去掉 "<image:" 和 ">"
-            # 验证是否为有效的base64
-            base64.b64decode(base64_part)  # 如果无效会抛出异常
-        except Exception as e:
-            self.skipTest(f"二维码字符串生成失败: {str(e)}")
-        
-        # 测试空值
-        qr_empty = self.Qrcode("")
-        result = qr_empty.toStr()
-        self.assertEqual(result, "")
-    
-    def test_qrcode_str_method(self):
-        """测试二维码__str__方法"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        qr = self.Qrcode("Test")
-        try:
-            str_result = str(qr)
-            expected = qr.toStr()
-            self.assertEqual(str_result, expected)
-        except Exception as e:
-            self.skipTest(f"二维码__str__方法失败: {str(e)}")
-    
-    def test_barcode_creation(self):
-        """测试条形码创建"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        # 创建条形码
-        bc = self.Barcode("123456789")
-        self.assertEqual(bc.value, "123456789")
-        self.assertEqual(bc.codeType, "code128")  # 默认类型
-        
-        # 自定义类型
-        bc_custom = self.Barcode("123456789", "code39")
-        self.assertEqual(bc_custom.codeType, "code39")
-    
-    def test_barcode_toByte(self):
-        """测试条形码转字节"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        bc = self.Barcode("123456789")
-        try:
-            byte_data = bc.toByte()
-            self.assertIsInstance(byte_data, bytes)
-            self.assertGreater(len(byte_data), 0)
-        except Exception as e:
-            self.skipTest(f"条形码生成失败: {str(e)}")
-    
-    def test_barcode_toStr(self):
-        """测试条形码转base64字符串"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        # 测试正常值
-        bc = self.Barcode("123456789")
-        try:
-            str_data = bc.toStr()
-            self.assertIsInstance(str_data, str)
-            
-            # 如果成功，应该是base64格式
-            if not str_data.startswith("ERROR:"):
-                self.assertTrue(str_data.startswith("<image:"))
-                self.assertTrue(str_data.endswith(">"))
-                
-                # 提取base64部分
-                base64_part = str_data[7:-1]  # 去掉 "<image:" 和 ">"
-                # 验证是否为有效的base64
-                base64.b64decode(base64_part)
-        except Exception as e:
-            self.skipTest(f"条形码字符串生成失败: {str(e)}")
-        
-        # 测试空值
-        bc_empty = self.Barcode("")
-        result = bc_empty.toStr()
-        self.assertEqual(result, "")
-    
-    def test_barcode_invalid_data(self):
-        """测试条形码无效数据处理"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        # 测试可能导致错误的数据
-        bc = self.Barcode("invalid_barcode_data!@#$%^&*()")
-        try:
-            result = bc.toStr()
-            # 如果出错，应该返回ERROR:开头的字符串
-            if result.startswith("ERROR:"):
-                self.assertIn("ERROR:", result)
-            else:
-                # 如果没出错，应该是正常的base64格式
-                self.assertTrue(result.startswith("<image:"))
-        except Exception as e:
-            self.skipTest(f"条形码错误处理测试失败: {str(e)}")
-    
-    def test_barcode_str_method(self):
-        """测试条形码__str__方法"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        bc = self.Barcode("123456789")
-        try:
-            str_result = str(bc)
-            expected = bc.toStr()
-            self.assertEqual(str_result, expected)
-        except Exception as e:
-            self.skipTest(f"条形码__str__方法失败: {str(e)}")
-
-
-if __name__ == '__main__':
-    unittest.main() 

tests/test_string_utils.py

@@ -1,174 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试字符串工具模块
-"""
-import unittest
-import re
-import os
-import tempfile
-from jit_utils.string import (
-    randomString, randomNum, getUuidStr, md5Bytes, md5Str, 
-    lowercase, capitalize, getFileMd5, getRandomField, getRandom,
-    genrSublist, renderTemplateString
-)
-
-
-class TestStringUtils(unittest.TestCase):
-    """字符串工具测试类"""
-    
-    def test_randomString(self):
-        """测试随机字符串生成"""
-        # 测试默认长度
-        result = randomString()
-        self.assertEqual(len(result), 8)
-        self.assertTrue(result.isalnum())
-        
-        # 测试自定义长度
-        result = randomString(12)
-        self.assertEqual(len(result), 12)
-        self.assertTrue(result.isalnum())
-        
-        # 测试两次生成的结果不同（概率很高）
-        result1 = randomString(20)
-        result2 = randomString(20)
-        self.assertNotEqual(result1, result2)
-    
-    def test_randomNum(self):
-        """测试随机数字生成"""
-        # 测试默认6位数字
-        result = randomNum()
-        self.assertEqual(len(result), 6)
-        self.assertTrue(result.isdigit())
-        
-        # 测试自定义位数
-        result = randomNum(4)
-        self.assertEqual(len(result), 4)
-        self.assertTrue(result.isdigit())
-        
-        # 测试两次生成的结果不同（概率很高）
-        result1 = randomNum(8)
-        result2 = randomNum(8)
-        self.assertNotEqual(result1, result2)
-    
-    def test_getUuidStr(self):
-        """测试UUID字符串生成"""
-        result = getUuidStr()
-        # UUID去掉连字符后应该是32位十六进制字符串
-        self.assertEqual(len(result), 32)
-        self.assertTrue(re.match(r'^[a-f0-9]{32}$', result))
-        
-        # 测试两次生成的UUID不同
-        result1 = getUuidStr()
-        result2 = getUuidStr()
-        self.assertNotEqual(result1, result2)
-    
-    def test_md5Bytes(self):
-        """测试字节数据MD5加密"""
-        test_data = b"hello world"
-        result = md5Bytes(test_data)
-        expected = "5eb63bbbe01eeed093cb22bb8f5acdc3"
-        self.assertEqual(result, expected)
-        
-        # 测试空字节
-        result = md5Bytes(b"")
-        expected = "d41d8cd98f00b204e9800998ecf8427e"
-        self.assertEqual(result, expected)
-    
-    def test_md5Str(self):
-        """测试字符串MD5加密"""
-        test_str = "hello world"
-        result = md5Str(test_str)
-        expected = "5eb63bbbe01eeed093cb22bb8f5acdc3"
-        self.assertEqual(result, expected)
-        
-        # 测试不同编码
-        result = md5Str("你好", "utf-8")
-        self.assertEqual(len(result), 32)
-        self.assertTrue(re.match(r'^[a-f0-9]{32}$', result))
-    
-    def test_lowercase(self):
-        """测试首字母小写"""
-        self.assertEqual(lowercase("Hello"), "hello")
-        self.assertEqual(lowercase("WORLD"), "wORLD")
-        self.assertEqual(lowercase("a"), "a")
-        self.assertEqual(lowercase(""), "")
-    
-    def test_capitalize(self):
-        """测试首字母大写"""
-        self.assertEqual(capitalize("hello"), "Hello")
-        self.assertEqual(capitalize("world"), "World")
-        self.assertEqual(capitalize("A"), "A")
-        self.assertEqual(capitalize(""), "")
-    
-    def test_getFileMd5(self):
-        """测试文件MD5计算"""
-        # 创建临时文件
-        with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
-            f.write("hello world")
-            temp_file = f.name
-        
-        try:
-            result = getFileMd5(temp_file)
-            expected = "5eb63bbbe01eeed093cb22bb8f5acdc3"
-            self.assertEqual(result, expected)
-        finally:
-            os.unlink(temp_file)
-        
-        # 测试不存在的文件
-        result = getFileMd5("non_existent_file.txt")
-        self.assertIsNone(result)
-    
-    def test_getRandomField(self):
-        """测试随机字段名生成"""
-        result = getRandomField()
-        self.assertTrue(result.startswith("fk"))
-        self.assertEqual(len(result), 6)  # "fk" + 4个字符
-        
-        result = getRandomField(6)
-        self.assertTrue(result.startswith("fk"))
-        self.assertEqual(len(result), 8)  # "fk" + 6个字符
-    
-    def test_getRandom(self):
-        """测试随机字符串生成（小写字母+数字）"""
-        result = getRandom()
-        self.assertEqual(len(result), 8)
-        self.assertTrue(re.match(r'^[a-z0-9]+$', result))
-        
-        result = getRandom(12)
-        self.assertEqual(len(result), 12)
-        self.assertTrue(re.match(r'^[a-z0-9]+$', result))
-    
-    def test_genrSublist(self):
-        """测试列表分割"""
-        test_list = list(range(10))
-        result = list(genrSublist(test_list, 3))
-        
-        expected = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
-        self.assertEqual(result, expected)
-        
-        # 测试整除的情况
-        test_list = list(range(9))
-        result = list(genrSublist(test_list, 3))
-        expected = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
-        self.assertEqual(result, expected)
-    
-    def test_renderTemplateString(self):
-        """测试模板字符串渲染"""
-        template = "Hello {{name}}, you are {{age}} years old"
-        result = renderTemplateString(template, name="Alice", age=25)
-        expected = "Hello Alice, you are 25 years old"
-        self.assertEqual(result, expected)
-        
-        # 测试缺失变量
-        result = renderTemplateString("Hello {{name}}", age=25)
-        expected = "Hello "
-        self.assertEqual(result, expected)
-        
-        # 测试无变量
-        result = renderTemplateString("Hello World")
-        expected = "Hello World"
-        self.assertEqual(result, expected)
-
-
-if __name__ == '__main__':
-    unittest.main() 

tests/test_time_utils.py

@@ -1,185 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试时间工具模块
-"""
-import unittest
-import datetime
-import time
-from unittest.mock import patch
-
-
-class TestTimeUtils(unittest.TestCase):
-    """时间工具测试类"""
-    
-    def setUp(self):
-        """测试设置"""
-        # 由于时间模块可能有导包问题，我们使用try-except来导入
-        try:
-            from jit_utils.time import (
-                getTimestamp, timeStampToDateTime, strToTimestamp,
-                formatNow, datetime2string, string2datetime,
-                timestamp2date, timestamp2string, cmpTsSameDay
-            )
-            self.time_module_available = True
-            self.getTimestamp = getTimestamp
-            self.timeStampToDateTime = timeStampToDateTime
-            self.strToTimestamp = strToTimestamp
-            self.formatNow = formatNow
-            self.datetime2string = datetime2string
-            self.string2datetime = string2datetime
-            self.timestamp2date = timestamp2date
-            self.timestamp2string = timestamp2string
-            self.cmpTsSameDay = cmpTsSameDay
-        except ImportError as e:
-            self.time_module_available = False
-            self.import_error = str(e)
-    
-    def test_getTimestamp(self):
-        """测试获取时间戳"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        timestamp = self.getTimestamp()
-        self.assertIsInstance(timestamp, int)
-        # 时间戳应该是13位数字（毫秒级）
-        self.assertGreater(timestamp, 1000000000000)
-        self.assertLess(timestamp, 9999999999999)
-    
-    def test_timeStampToDateTime(self):
-        """测试时间戳转datetime"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        try:
-            # 测试秒级时间戳
-            timestamp_sec = 1640995200  # 2022-01-01 00:00:00
-            result = self.timeStampToDateTime(timestamp_sec)
-            self.assertIsInstance(result, datetime.datetime)
-            self.assertEqual(result.year, 2022)
-            self.assertEqual(result.month, 1)
-            self.assertEqual(result.day, 1)
-            
-            # 测试毫秒级时间戳
-            timestamp_ms = 1640995200000
-            result = self.timeStampToDateTime(timestamp_ms)
-            self.assertIsInstance(result, datetime.datetime)
-            self.assertEqual(result.year, 2022)
-        except Exception as e:
-            self.skipTest(f"时间戳转换函数出错: {str(e)}")
-    
-    def test_formatNow(self):
-        """测试格式化当前时间"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 测试默认格式
-        result = self.formatNow()
-        self.assertIsInstance(result, str)
-        # 应该匹配 YYYY-MM-DD 格式
-        import re
-        self.assertTrue(re.match(r'^\d{4}-\d{2}-\d{2}$', result))
-        
-        # 测试自定义格式
-        result = self.formatNow("%Y%m%d")
-        self.assertTrue(re.match(r'^\d{8}$', result))
-    
-    def test_datetime2string(self):
-        """测试datetime转字符串"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 测试正常的datetime对象
-        dt = datetime.datetime(2022, 1, 1, 12, 30, 45)
-        result = self.datetime2string(dt)
-        expected = "2022-01-01"
-        self.assertEqual(result, expected)
-        
-        # 测试自定义格式
-        result = self.datetime2string(dt, "%Y-%m-%d %H:%M:%S")
-        expected = "2022-01-01 12:30:45"
-        self.assertEqual(result, expected)
-        
-        # 测试非datetime对象
-        result = self.datetime2string("not_datetime")
-        self.assertEqual(result, "")
-    
-    def test_string2datetime(self):
-        """测试字符串转datetime"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 测试默认格式
-        date_str = "2022-01-01"
-        result = self.string2datetime(date_str)
-        self.assertIsInstance(result, datetime.datetime)
-        self.assertEqual(result.year, 2022)
-        self.assertEqual(result.month, 1)
-        self.assertEqual(result.day, 1)
-        
-        # 测试自定义格式
-        date_str = "01/01/2022"
-        result = self.string2datetime(date_str, "%m/%d/%Y")
-        self.assertIsInstance(result, datetime.datetime)
-        self.assertEqual(result.year, 2022)
-    
-    def test_timestamp2date(self):
-        """测试时间戳转日期字符串"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        timestamp = 1640995200  # 2022-01-01 00:00:00
-        result = self.timestamp2date(timestamp)
-        self.assertEqual(result, "2022-01-01")
-    
-    def test_timestamp2string(self):
-        """测试时间戳转格式化字符串"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        timestamp = 1640995200000  # 毫秒级时间戳
-        result = self.timestamp2string(timestamp)
-        self.assertIsInstance(result, str)
-        # 应该包含日期和时间
-        self.assertIn("2022-01-01", result)
-        
-        # 测试自定义格式
-        result = self.timestamp2string(timestamp, "%Y%m%d")
-        self.assertEqual(result, "20220101")
-    
-    def test_cmpTsSameDay(self):
-        """测试比较两个时间戳是否同一天"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 同一天的不同时间
-        ts1 = 1640995200000  # 2022-01-01 00:00:00
-        ts2 = 1641038400000  # 2022-01-01 12:00:00
-        result = self.cmpTsSameDay(ts1, ts2)
-        self.assertTrue(result)
-        
-        # 不同天
-        ts3 = 1641081600000  # 2022-01-02 00:00:00
-        result = self.cmpTsSameDay(ts1, ts3)
-        self.assertFalse(result)
-    
-    def test_basic_time_functions(self):
-        """测试基本时间函数（不依赖外部导入）"""
-        # 这些测试直接使用Python标准库，不依赖可能有问题的导入
-        
-        # 测试当前时间戳
-        now_ts = int(time.time() * 1000)
-        self.assertIsInstance(now_ts, int)
-        self.assertGreater(now_ts, 1000000000000)
-        
-        # 测试datetime操作
-        now_dt = datetime.datetime.now()
-        formatted = now_dt.strftime("%Y-%m-%d")
-        self.assertIsInstance(formatted, str)
-        
-        # 测试日期计算
-        tomorrow = now_dt + datetime.timedelta(days=1)
-        self.assertGreater(tomorrow, now_dt)
-
-
-if __name__ == '__main__':
-    unittest.main()