funcguard 0.1.1__tar.gz

funcguard-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tinycen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

funcguard-0.1.1/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.1
+Name: funcguard
+Version: 0.1.1
+Summary: A funcguard for Python.
+Home-page: https://github.com/tinycen/funcguard
+Author: tinycen
+Author-email: sky_ruocen@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# FuncGuard
+
+FuncGuard是一个Python库，提供了函数执行超时控制和重试机制的实用工具。
+
+## 功能特点
+
+- 函数执行超时控制
+- 函数执行失败自动重试
+- HTTP请求封装（支持自动重试）
+
+## 安装/升级
+
+```bash
+pip install funcguard
+```
+
+```bash
+pip install --upgrade funcguard
+```
+
+
+## 使用方法
+
+### 超时控制
+
+使用`timeout_handler`函数可以控制函数的执行时间，防止函数运行时间过长：
+
+```python
+from funcguard.core import timeout_handler
+
+def long_running_function():
+    # 模拟一个耗时操作
+    import time
+    time.sleep(10)
+    return "操作完成"
+
+try:
+    # 设置超时时间为5秒
+    result = timeout_handler(long_running_function, execution_timeout=5)
+    print(result)
+except TimeoutError as e:
+    print(f"捕获到超时错误: {e}")
+```
+
+### 重试机制
+
+使用`retry_function`函数可以在函数执行失败时自动重试：
+
+```python
+from funcguard.core import retry_function
+
+def unstable_function():
+    # 模拟一个可能失败的操作
+    import random
+    if random.random() < 0.7:  # 70%的概率失败
+        raise Exception("随机错误")
+    return "操作成功"
+
+try:
+    # 最多重试3次，每次执行超时时间为10秒
+    result = retry_function(unstable_function, max_retries=3, execute_timeout=10, task_name="测试任务")
+    print(result)
+except Exception as e:
+    print(f"重试后仍然失败: {e}")
+```
+
+### HTTP请求
+
+使用`send_request`函数发送HTTP请求，支持自动重试：
+
+```python
+from funcguard.tools import send_request
+
+# 不使用重试
+response = send_request(
+    method="GET",
+    url="https://api.example.com/data",
+    headers={"Content-Type": "application/json"},
+    timeout=30
+)
+print(response)
+
+# 使用重试
+response = send_request(
+    method="POST",
+    url="https://api.example.com/data",
+    headers={"Content-Type": "application/json"},
+    data={"key": "value"},
+    timeout=30,
+    auto_retry={
+        "task_name": "API请求",
+        "max_retries": 3,
+        "execute_timeout": 60
+    }
+)
+print(response)
+```
+
+## API文档
+
+### funcguard.core
+
+#### timeout_handler(func, args=(), kwargs=None, execution_timeout=90)
+
+- **参数**:
+  - `func`: 需要执行的目标函数
+  - `args`: 目标函数的位置参数，默认为空元组
+  - `kwargs`: 目标函数的关键字参数，默认为None
+  - `execution_timeout`: 函数执行的超时时间，单位为秒，默认为90秒
+- **返回值**: 目标函数的返回值
+- **异常**: `TimeoutError` - 当函数执行超过指定时间时抛出
+
+#### retry_function(func, max_retries=5, execute_timeout=90, task_name="", *args, **kwargs)
+
+- **参数**:
+  - `func`: 需要重试的函数
+  - `max_retries`: 最大重试次数，默认为5
+  - `execute_timeout`: 执行超时时间，默认为90秒
+  - `task_name`: 任务名称，用于打印日志
+  - `args`: func的位置参数
+  - `kwargs`: func的关键字参数
+- **返回值**: func的返回值
+- **异常**: 当重试次数用尽后仍然失败时，抛出最后一次的异常
+
+### funcguard.tools
+
+#### send_request(method, url, headers, data=None, return_type="json", timeout=60, auto_retry=None)
+
+- **参数**:
+  - `method`: HTTP方法（GET, POST等）
+  - `url`: 请求URL
+  - `headers`: 请求头
+  - `data`: 请求数据，默认为None
+  - `return_type`: 返回类型，可选"json"、"response"或"text"，默认为"json"
+  - `timeout`: 请求超时时间，单位为秒，默认为60
+  - `auto_retry`: 自动重试配置，格式为`{"task_name": "", "max_retries": 5, "execute_timeout": 90}`，默认为None
+- **返回值**: 根据return_type参数返回不同格式的响应数据
+- **异常**: 当请求失败且重试次数用尽后，抛出相应的异常
+
+## 许可证
+
+MIT License

funcguard-0.1.1/README.md

@@ -0,0 +1,142 @@
+# FuncGuard
+
+FuncGuard是一个Python库，提供了函数执行超时控制和重试机制的实用工具。
+
+## 功能特点
+
+- 函数执行超时控制
+- 函数执行失败自动重试
+- HTTP请求封装（支持自动重试）
+
+## 安装/升级
+
+```bash
+pip install funcguard
+```
+
+```bash
+pip install --upgrade funcguard
+```
+
+
+## 使用方法
+
+### 超时控制
+
+使用`timeout_handler`函数可以控制函数的执行时间，防止函数运行时间过长：
+
+```python
+from funcguard.core import timeout_handler
+
+def long_running_function():
+    # 模拟一个耗时操作
+    import time
+    time.sleep(10)
+    return "操作完成"
+
+try:
+    # 设置超时时间为5秒
+    result = timeout_handler(long_running_function, execution_timeout=5)
+    print(result)
+except TimeoutError as e:
+    print(f"捕获到超时错误: {e}")
+```
+
+### 重试机制
+
+使用`retry_function`函数可以在函数执行失败时自动重试：
+
+```python
+from funcguard.core import retry_function
+
+def unstable_function():
+    # 模拟一个可能失败的操作
+    import random
+    if random.random() < 0.7:  # 70%的概率失败
+        raise Exception("随机错误")
+    return "操作成功"
+
+try:
+    # 最多重试3次，每次执行超时时间为10秒
+    result = retry_function(unstable_function, max_retries=3, execute_timeout=10, task_name="测试任务")
+    print(result)
+except Exception as e:
+    print(f"重试后仍然失败: {e}")
+```
+
+### HTTP请求
+
+使用`send_request`函数发送HTTP请求，支持自动重试：
+
+```python
+from funcguard.tools import send_request
+
+# 不使用重试
+response = send_request(
+    method="GET",
+    url="https://api.example.com/data",
+    headers={"Content-Type": "application/json"},
+    timeout=30
+)
+print(response)
+
+# 使用重试
+response = send_request(
+    method="POST",
+    url="https://api.example.com/data",
+    headers={"Content-Type": "application/json"},
+    data={"key": "value"},
+    timeout=30,
+    auto_retry={
+        "task_name": "API请求",
+        "max_retries": 3,
+        "execute_timeout": 60
+    }
+)
+print(response)
+```
+
+## API文档
+
+### funcguard.core
+
+#### timeout_handler(func, args=(), kwargs=None, execution_timeout=90)
+
+- **参数**:
+  - `func`: 需要执行的目标函数
+  - `args`: 目标函数的位置参数，默认为空元组
+  - `kwargs`: 目标函数的关键字参数，默认为None
+  - `execution_timeout`: 函数执行的超时时间，单位为秒，默认为90秒
+- **返回值**: 目标函数的返回值
+- **异常**: `TimeoutError` - 当函数执行超过指定时间时抛出
+
+#### retry_function(func, max_retries=5, execute_timeout=90, task_name="", *args, **kwargs)
+
+- **参数**:
+  - `func`: 需要重试的函数
+  - `max_retries`: 最大重试次数，默认为5
+  - `execute_timeout`: 执行超时时间，默认为90秒
+  - `task_name`: 任务名称，用于打印日志
+  - `args`: func的位置参数
+  - `kwargs`: func的关键字参数
+- **返回值**: func的返回值
+- **异常**: 当重试次数用尽后仍然失败时，抛出最后一次的异常
+
+### funcguard.tools
+
+#### send_request(method, url, headers, data=None, return_type="json", timeout=60, auto_retry=None)
+
+- **参数**:
+  - `method`: HTTP方法（GET, POST等）
+  - `url`: 请求URL
+  - `headers`: 请求头
+  - `data`: 请求数据，默认为None
+  - `return_type`: 返回类型，可选"json"、"response"或"text"，默认为"json"
+  - `timeout`: 请求超时时间，单位为秒，默认为60
+  - `auto_retry`: 自动重试配置，格式为`{"task_name": "", "max_retries": 5, "execute_timeout": 90}`，默认为None
+- **返回值**: 根据return_type参数返回不同格式的响应数据
+- **异常**: 当请求失败且重试次数用尽后，抛出相应的异常
+
+## 许可证
+
+MIT License

funcguard-0.1.1/funcguard/__init__.py

@@ -0,0 +1,7 @@
+from .core import timeout_handler, retry_function
+from .tools import send_request
+
+__author__ = "ruocen"
+
+# 暴露主要接口
+__all__ = ["timeout_handler", "retry_function","send_request"]

funcguard-0.1.1/funcguard/core.py

@@ -0,0 +1,81 @@
+class FuncguardTimeoutError(Exception):
+    pass
+
+import time
+from concurrent.futures import ThreadPoolExecutor , TimeoutError
+
+# 计算函数运行时间
+def timeout_handler( func, args = (), kwargs = None, execution_timeout = 90 ):
+    """
+    使用 ThreadPoolExecutor 实现超时控制。
+
+    :param func: 需要执行的目标函数
+    :param args: 目标函数的位置参数，默认为空元组
+    :param kwargs: 目标函数的关键字参数，默认为 None
+    :param execution_timeout: 函数执行的超时时间，单位为秒，默认为 90 秒
+    :return: 目标函数的返回值
+    """
+    if kwargs is None:
+        kwargs = { }
+
+    with ThreadPoolExecutor( max_workers = 1 ) as executor:
+        future = executor.submit( func, *args, **kwargs )
+        try:
+            return future.result( timeout = execution_timeout )
+        except TimeoutError:
+            error_message = f"TimeoutError：函数 {func.__name__} 执行时间超过 {execution_timeout} 秒"
+            # print( error_message )
+            raise FuncguardTimeoutError( error_message )
+
+
+# 重试函数
+def retry_function( func , max_retries = 5 , execute_timeout = 90 , task_name = "" , *args , **kwargs ) :
+    """
+    重试函数的通用封装。
+    :param func: 需要重试的函数
+    :param max_retries: 最大重试次数
+    :param execute_timeout: 执行超时时间
+    :param task_name: 任务名称，用于打印日志
+    :param args: func的位置参数
+    :param kwargs: func的关键字参数
+    :return: func的返回值
+    """
+    retry_count = 0
+    current_timeout = execute_timeout  # 初始化当前超时时间为传入的execute_timeout
+
+    # 检查原始kwargs中是否包含timeout参数
+    original_timeout = kwargs.get( 'timeout' , 0 )
+
+    if current_timeout < original_timeout :
+        current_timeout = original_timeout + 30
+
+    last_exception = None
+    while retry_count < max_retries :
+        try :
+            result = timeout_handler( func , args = args , kwargs = kwargs , execution_timeout = current_timeout )
+            return result  # 如果调用成功，则返回结果
+
+        except BaseException as e :
+            last_exception = e
+            retry_count += 1
+            print( e )
+            if "TimeoutError" in str( e ) :
+                # 计划延长的时间
+                extend_time = 30 * retry_count
+
+                # 增加执行超时时间
+                current_timeout += extend_time
+
+                # 如果原始函数有timeout参数，也增加它
+                if original_timeout > 0 :
+                    kwargs[ 'timeout' ] = original_timeout + extend_time
+                    # print( f"增加timeout参数至: {kwargs[ 'timeout' ]}秒" )
+
+            print( f"{task_name} : {func.__name__} 请求失败，正在重试... (第{retry_count}次)" )
+            if retry_count < max_retries :  # 如果不是最后一次重试，则等待一段时间后重试
+                time.sleep( 5 * retry_count )
+    print( f"请求失败次数达到上限：{max_retries}次，终止请求。重试了{retry_count}次" )
+    # 这里可以添加更多的错误处理逻辑，例如记录错误信息
+    if last_exception:
+        raise last_exception  # 重新抛出最后一个异常
+    return None

funcguard-0.1.1/funcguard/tools.py

@@ -0,0 +1,46 @@
+import json
+import requests
+from . import core
+# 使用 from .core import retry_function 会导致测试失败
+
+# 发起请求
+def send_request( method , url , headers , data = None , return_type = "json" , timeout = 60 , auto_retry = None ) :
+    '''
+    发送HTTP请求的通用函数
+    
+    :param method: HTTP方法（GET, POST等）
+    :param url: 请求URL
+    :param headers: 请求头
+    :param data: 请求数据
+    :param return_type: 返回类型（json, text, response）
+    :param timeout: 请求超时时间
+    :param auto_retry: 自动重试配置，格式为：
+                     {"task_name": "任务名称", "max_retries": 最大重试次数, "execute_timeout": 执行超时时间}
+    :return: 请求结果
+    '''
+    if data is None :
+        payload = { }
+    else :
+        if (isinstance( data , dict ) or isinstance( data , list )) and data != { } :
+            payload = json.dumps( data , ensure_ascii = False )
+        else :
+            payload = data
+    if auto_retry is None :
+        response = requests.request( method , url , headers = headers , data = payload , timeout = timeout )
+    else :
+        max_retries = auto_retry.get( "max_retries" , 5 )
+        execute_timeout = auto_retry.get( "execute_timeout" , 90 )
+        task_name = auto_retry.get( "task_name" , "" )
+        response = core.retry_function( requests.request , max_retries , execute_timeout , task_name , method , url ,
+                                        headers = headers , data = payload , timeout = timeout )
+
+    if response is None:
+        raise ValueError("请求返回的响应为None")
+    
+    if return_type == "json" :
+        result = response.json()
+    elif return_type == "response" :
+        return response
+    else :
+        result = response.text
+    return result

funcguard-0.1.1/funcguard.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.1
+Name: funcguard
+Version: 0.1.1
+Summary: A funcguard for Python.
+Home-page: https://github.com/tinycen/funcguard
+Author: tinycen
+Author-email: sky_ruocen@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# FuncGuard
+
+FuncGuard是一个Python库，提供了函数执行超时控制和重试机制的实用工具。
+
+## 功能特点
+
+- 函数执行超时控制
+- 函数执行失败自动重试
+- HTTP请求封装（支持自动重试）
+
+## 安装/升级
+
+```bash
+pip install funcguard
+```
+
+```bash
+pip install --upgrade funcguard
+```
+
+
+## 使用方法
+
+### 超时控制
+
+使用`timeout_handler`函数可以控制函数的执行时间，防止函数运行时间过长：
+
+```python
+from funcguard.core import timeout_handler
+
+def long_running_function():
+    # 模拟一个耗时操作
+    import time
+    time.sleep(10)
+    return "操作完成"
+
+try:
+    # 设置超时时间为5秒
+    result = timeout_handler(long_running_function, execution_timeout=5)
+    print(result)
+except TimeoutError as e:
+    print(f"捕获到超时错误: {e}")
+```
+
+### 重试机制
+
+使用`retry_function`函数可以在函数执行失败时自动重试：
+
+```python
+from funcguard.core import retry_function
+
+def unstable_function():
+    # 模拟一个可能失败的操作
+    import random
+    if random.random() < 0.7:  # 70%的概率失败
+        raise Exception("随机错误")
+    return "操作成功"
+
+try:
+    # 最多重试3次，每次执行超时时间为10秒
+    result = retry_function(unstable_function, max_retries=3, execute_timeout=10, task_name="测试任务")
+    print(result)
+except Exception as e:
+    print(f"重试后仍然失败: {e}")
+```
+
+### HTTP请求
+
+使用`send_request`函数发送HTTP请求，支持自动重试：
+
+```python
+from funcguard.tools import send_request
+
+# 不使用重试
+response = send_request(
+    method="GET",
+    url="https://api.example.com/data",
+    headers={"Content-Type": "application/json"},
+    timeout=30
+)
+print(response)
+
+# 使用重试
+response = send_request(
+    method="POST",
+    url="https://api.example.com/data",
+    headers={"Content-Type": "application/json"},
+    data={"key": "value"},
+    timeout=30,
+    auto_retry={
+        "task_name": "API请求",
+        "max_retries": 3,
+        "execute_timeout": 60
+    }
+)
+print(response)
+```
+
+## API文档
+
+### funcguard.core
+
+#### timeout_handler(func, args=(), kwargs=None, execution_timeout=90)
+
+- **参数**:
+  - `func`: 需要执行的目标函数
+  - `args`: 目标函数的位置参数，默认为空元组
+  - `kwargs`: 目标函数的关键字参数，默认为None
+  - `execution_timeout`: 函数执行的超时时间，单位为秒，默认为90秒
+- **返回值**: 目标函数的返回值
+- **异常**: `TimeoutError` - 当函数执行超过指定时间时抛出
+
+#### retry_function(func, max_retries=5, execute_timeout=90, task_name="", *args, **kwargs)
+
+- **参数**:
+  - `func`: 需要重试的函数
+  - `max_retries`: 最大重试次数，默认为5
+  - `execute_timeout`: 执行超时时间，默认为90秒
+  - `task_name`: 任务名称，用于打印日志
+  - `args`: func的位置参数
+  - `kwargs`: func的关键字参数
+- **返回值**: func的返回值
+- **异常**: 当重试次数用尽后仍然失败时，抛出最后一次的异常
+
+### funcguard.tools
+
+#### send_request(method, url, headers, data=None, return_type="json", timeout=60, auto_retry=None)
+
+- **参数**:
+  - `method`: HTTP方法（GET, POST等）
+  - `url`: 请求URL
+  - `headers`: 请求头
+  - `data`: 请求数据，默认为None
+  - `return_type`: 返回类型，可选"json"、"response"或"text"，默认为"json"
+  - `timeout`: 请求超时时间，单位为秒，默认为60
+  - `auto_retry`: 自动重试配置，格式为`{"task_name": "", "max_retries": 5, "execute_timeout": 90}`，默认为None
+- **返回值**: 根据return_type参数返回不同格式的响应数据
+- **异常**: 当请求失败且重试次数用尽后，抛出相应的异常
+
+## 许可证
+
+MIT License

funcguard-0.1.1/funcguard.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+setup.py
+funcguard/__init__.py
+funcguard/core.py
+funcguard/tools.py
+funcguard.egg-info/PKG-INFO
+funcguard.egg-info/SOURCES.txt
+funcguard.egg-info/dependency_links.txt
+funcguard.egg-info/not-zip-safe
+funcguard.egg-info/requires.txt
+funcguard.egg-info/top_level.txt
+tests/__init__.py
+tests/run_test.py
+tests/test_core.py
+tests/test_tools.py

funcguard-0.1.1/funcguard.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

funcguard-0.1.1/funcguard.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

funcguard-0.1.1/funcguard.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

funcguard-0.1.1/funcguard.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+funcguard
+tests

funcguard-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

funcguard-0.1.1/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+# 读取README文件
+try:
+    with open('README.md', 'r', encoding='utf-8') as f:
+        long_description = f.read()
+except FileNotFoundError:
+    long_description = 'A funcguard for Python.'
+
+setup(
+    name='funcguard',
+    version='0.1.1',
+    packages=find_packages(),
+    install_requires=[
+        'requests',
+    ],
+    author='tinycen',
+    author_email='sky_ruocen@qq.com',
+    description='A funcguard for Python.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/tinycen/funcguard',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.10',
+    include_package_data=True,
+    zip_safe=False,
+)

funcguard-0.1.1/tests/__init__.py

@@ -0,0 +1 @@
+# 测试包初始化文件

funcguard-0.1.1/tests/run_test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+测试运行脚本
+运行所有测试用例
+"""
+
+import unittest
+import sys
+import os
+
+# 添加项目根目录到Python路径
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, project_root)
+
+# 导入测试模块
+from tests.test_core import TestTimeoutHandler, TestRetryFunction
+from tests.test_tools import TestSendRequest
+
+
+def run_all_tests():
+    """运行所有测试"""
+    # 创建测试套件
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    
+    # 添加测试类
+    suite.addTests(loader.loadTestsFromTestCase(TestTimeoutHandler))
+    suite.addTests(loader.loadTestsFromTestCase(TestRetryFunction))
+    suite.addTests(loader.loadTestsFromTestCase(TestSendRequest))
+    
+    # 运行测试
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    return result.wasSuccessful()
+
+
+if __name__ == '__main__':
+    success = run_all_tests()
+    sys.exit(0 if success else 1)

funcguard-0.1.1/tests/test_core.py

@@ -0,0 +1,109 @@
+import time
+import unittest
+from unittest.mock import patch
+
+from funcguard.core import timeout_handler, retry_function
+
+
+class TestTimeoutHandler(unittest.TestCase):
+    """测试timeout_handler函数"""
+    
+    def test_normal_execution(self):
+        """测试正常执行的函数"""
+        def quick_function():
+            time.sleep(0.1)
+            return "success"
+        
+        result = timeout_handler(quick_function, execution_timeout=2)
+        self.assertEqual(result, "success")
+    
+    def test_timeout_execution(self):
+        """测试超时的函数"""
+        def slow_function():
+            time.sleep(2)
+            return "should not reach here"
+        
+        from funcguard.core import FuncguardTimeoutError
+        with self.assertRaises(FuncguardTimeoutError) as context:
+            timeout_handler(slow_function, execution_timeout=1)
+        
+        self.assertIn("执行时间超过 1 秒", str(context.exception))
+    
+    def test_function_with_args(self):
+        """测试带参数的函数"""
+        def add_numbers(a, b):
+            return a + b
+        
+        result = timeout_handler(add_numbers, args=(3, 4), execution_timeout=2)
+        self.assertEqual(result, 7)
+    
+    def test_function_with_kwargs(self):
+        """测试带关键字参数的函数"""
+        def greet(name, greeting="Hello"):
+            return f"{greeting}, {name}!"
+        
+        result = timeout_handler(greet, kwargs={"name": "World", "greeting": "Hi"}, execution_timeout=2)
+        self.assertEqual(result, "Hi, World!")
+
+
+class TestRetryFunction(unittest.TestCase):
+    """测试retry_function函数"""
+    
+    def test_successful_first_try(self):
+        """测试第一次就成功的函数"""
+        def always_success():
+            return "success"
+        
+        result = retry_function(always_success, max_retries=2, task_name="test")
+        self.assertEqual(result, "success")
+    
+    def test_retry_until_success(self):
+        """测试重试后成功的函数"""
+        attempts = []
+        
+        def sometimes_fail():
+            attempts.append(len(attempts))
+            if len(attempts) < 2:
+                raise ValueError("Not yet")
+            return "finally success"
+        
+        result = retry_function(sometimes_fail, max_retries=2, task_name="test")
+        self.assertEqual(result, "finally success")
+        self.assertEqual(len(attempts), 2)
+    
+    def test_exhaust_all_retries(self):
+        """测试耗尽所有重试次数"""
+        def always_fail():
+            raise RuntimeError("Always fails")
+        
+        with self.assertRaises(RuntimeError) as context:
+            retry_function(always_fail, max_retries=2, task_name="test")
+        
+        self.assertEqual(str(context.exception), "Always fails")
+    
+    def test_timeout_in_retry(self):
+        """测试重试中的超时处理"""
+        def timeout_function():
+            time.sleep(2)
+            return "should timeout"
+        
+        # retry_function会在重试耗尽后抛出最后的异常
+        from funcguard.core import FuncguardTimeoutError
+        with self.assertRaises(FuncguardTimeoutError):
+            retry_function(timeout_function, max_retries=1, execute_timeout=1, task_name="test")
+    
+    @patch('time.sleep')
+    def test_retry_with_custom_delay(self, mock_sleep):
+        """测试重试延迟"""
+        def always_fail():
+            raise ValueError("test")
+        
+        with self.assertRaises(ValueError):
+            retry_function(always_fail, max_retries=2, task_name="test")
+        
+        # 验证sleep被调用了正确的次数
+        self.assertEqual(mock_sleep.call_count, 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

funcguard-0.1.1/tests/test_tools.py

@@ -0,0 +1,156 @@
+import json
+import unittest
+from unittest.mock import patch, MagicMock
+import requests
+
+from funcguard.tools import send_request
+
+
+class MockResponse:
+    """模拟requests响应"""
+    
+    def __init__(self, json_data=None, text="", status_code=200):
+        self.json_data = json_data or {}
+        self.text = text
+        self.status_code = status_code
+    
+    def json(self):
+        return self.json_data
+
+
+class TestSendRequest(unittest.TestCase):
+    """测试send_request函数"""
+    
+    @patch('requests.request')
+    def test_get_request_json_response(self, mock_request):
+        """测试GET请求返回JSON"""
+        mock_response = MockResponse(json_data={"key": "value"})
+        mock_request.return_value = mock_response
+        
+        result = send_request(
+            method="GET",
+            url="https://api.example.com/data",
+            headers={"Content-Type": "application/json"}
+        )
+        
+        self.assertEqual(result, {"key": "value"})
+        mock_request.assert_called_once()
+    
+    @patch('requests.request')
+    def test_post_request_with_data(self, mock_request):
+        """测试POST请求带数据"""
+        mock_response = MockResponse(json_data={"status": "created"})
+        mock_request.return_value = mock_response
+        
+        result = send_request(
+            method="POST",
+            url="https://api.example.com/users",
+            headers={"Content-Type": "application/json"},
+            data={"name": "test", "email": "test@example.com"}
+        )
+        
+        self.assertEqual(result, {"status": "created"})
+        mock_request.assert_called_once()
+    
+    @patch('requests.request')
+    def test_return_response_object(self, mock_request):
+        """测试返回response对象"""
+        mock_response = MockResponse(text="raw response")
+        mock_request.return_value = mock_response
+        
+        result = send_request(
+            method="GET",
+            url="https://api.example.com/raw",
+            headers={},
+            return_type="response"
+        )
+        
+        self.assertEqual(result, mock_response)
+    
+    @patch('requests.request')
+    def test_return_text_response(self, mock_request):
+        """测试返回文本响应"""
+        mock_response = MockResponse(text="plain text response")
+        mock_request.return_value = mock_response
+        
+        result = send_request(
+            method="GET",
+            url="https://api.example.com/text",
+            headers={},
+            return_type="text"
+        )
+        
+        self.assertEqual(result, "plain text response")
+    
+    @patch('requests.request')
+    def test_custom_timeout(self, mock_request):
+        """测试自定义超时时间"""
+        mock_response = MockResponse()
+        mock_request.return_value = mock_response
+        
+        send_request(
+            method="GET",
+            url="https://api.example.com/data",
+            headers={},
+            timeout=30
+        )
+        
+        mock_request.assert_called_once()
+    
+    @patch('funcguard.core.retry_function')
+    @patch('requests.request')
+    def test_auto_retry_enabled(self, mock_request, mock_retry):
+        """测试启用自动重试"""
+        # 设置retry_function返回一个包含正确json数据的MockResponse对象
+        mock_response = MockResponse(json_data={"success": True})
+        mock_retry.return_value = mock_response
+        
+        result = send_request(
+            method="POST",
+            url="https://api.example.com/data",
+            headers={"Content-Type": "application/json"},
+            data={"key": "value"},
+            auto_retry={
+                "task_name": "API测试",
+                "max_retries": 3,
+                "execute_timeout": 60
+            }
+        )
+        
+        # 验证结果
+        if hasattr(result, 'json_data'):
+            # 如果result是MockResponse对象，直接比较其json_data
+            self.assertEqual(result.json_data, {"success": True})
+        else:
+            # 否则直接比较result
+            self.assertEqual(result, {"success": True})
+        mock_retry.assert_called_once()
+    
+    @patch('requests.request')
+    def test_none_response_raises_error(self, mock_request):
+        """测试None响应抛出错误"""
+        mock_request.return_value = None
+        
+        with self.assertRaises(ValueError) as context:
+            send_request("GET", "https://api.example.com/data", {})
+        
+        self.assertEqual(str(context.exception), "请求返回的响应为None")
+    
+    def test_invalid_return_type(self):
+        """测试无效的返回类型"""
+        with patch('requests.request') as mock_request:
+            mock_response = MockResponse()
+            mock_request.return_value = mock_response
+            
+            # 对于无效的return_type，函数会尝试访问response.text
+            result = send_request(
+                method="GET",
+                url="https://api.example.com/data",
+                headers={},
+                return_type="invalid"
+            )
+            self.assertEqual(result, "")
+
+
+if __name__ == '__main__':
+    unittest.main()