pytest-dsl 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

pytest_dsl/cli.py

@@ -64,8 +64,12 @@ def parse_args():
         )
         list_parser.add_argument(
             '--format', choices=['text', 'json'],
-            default='text',
-            help='输出格式：text(默认) 或 json'
+            default='json',
+            help='输出格式：json(默认) 或 text'
+        )
+        list_parser.add_argument(
+            '--output', '-o', type=str, default=None,
+            help='输出文件路径（仅对 json 格式有效，默认为 keywords.json）'
         )
         list_parser.add_argument(
             '--filter', type=str, default=None,
@@ -88,7 +92,10 @@ def parse_args():
         if '--list-keywords' in argv:
             parser.add_argument('--list-keywords', action='store_true')
             parser.add_argument(
-                '--format', choices=['text', 'json'], default='text'
+                '--format', choices=['text', 'json'], default='json'
+            )
+            parser.add_argument(
+                '--output', '-o', type=str, default=None
             )
             parser.add_argument('--filter', type=str, default=None)
             parser.add_argument(
@@ -178,13 +185,22 @@ def format_keyword_info_text(keyword_name, keyword_info, show_category=True):
             param_name = getattr(param, 'name', str(param))
             param_mapping = getattr(param, 'mapping', '')
             param_desc = getattr(param, 'description', '')
+            param_default = getattr(param, 'default', None)
 
+            # 构建参数描述
+            param_info = []
             if param_mapping and param_mapping != param_name:
-                lines.append(
-                    f"    {param_name} ({param_mapping}): {param_desc}"
-                )
+                param_info.append(f"{param_name} ({param_mapping})")
             else:
-                lines.append(f"    {param_name}: {param_desc}")
+                param_info.append(param_name)
+            
+            param_info.append(f": {param_desc}")
+            
+            # 添加默认值信息
+            if param_default is not None:
+                param_info.append(f" (默认值: {param_default})")
+            
+            lines.append(f"    {''.join(param_info)}")
     else:
         lines.append("  参数: 无")
 
@@ -221,6 +237,12 @@ def format_keyword_info_json(keyword_name, keyword_info):
             'mapping': getattr(param, 'mapping', ''),
             'description': getattr(param, 'description', '')
         }
+        
+        # 添加默认值信息
+        param_default = getattr(param, 'default', None)
+        if param_default is not None:
+            param_data['default'] = param_default
+        
         keyword_data['parameters'].append(param_data)
 
     # 函数文档
@@ -231,8 +253,8 @@ def format_keyword_info_json(keyword_name, keyword_info):
     return keyword_data
 
 
-def list_keywords(output_format='text', name_filter=None,
-                  category_filter='all'):
+def list_keywords(output_format='json', name_filter=None,
+                  category_filter='all', output_file=None):
     """罗列所有关键字信息"""
     import json
 
@@ -319,7 +341,25 @@ def list_keywords(output_format='text', name_filter=None,
             keyword_data = format_keyword_info_json(name, info)
             keywords_data['keywords'].append(keyword_data)
 
-        print(json.dumps(keywords_data, ensure_ascii=False, indent=2))
+        json_output = json.dumps(keywords_data, ensure_ascii=False, indent=2)
+        
+        # 确定输出文件名
+        if output_file is None:
+            output_file = 'keywords.json'
+        
+        # 写入到文件
+        try:
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(json_output)
+            print(f"关键字信息已保存到文件: {output_file}")
+            print(f"共 {total_count} 个关键字")
+            for cat, count in category_counts.items():
+                cat_names = {'builtin': '内置', 'custom': '自定义', 'remote': '远程'}
+                print(f"  {cat_names.get(cat, cat)}: {count} 个")
+        except Exception as e:
+            print(f"保存文件失败: {e}")
+            # 如果写入文件失败，则回退到打印
+            print(json_output)
 
 
 def load_yaml_variables(args):
@@ -433,16 +473,19 @@ def main():
         list_keywords(
             output_format=args.format,
             name_filter=args.filter,
-            category_filter=args.category
+            category_filter=args.category,
+            output_file=args.output
         )
     elif args.command == 'run':
         run_dsl_tests(args)
     elif args.command == 'list-keywords-compat':
         # 向后兼容：旧的--list-keywords格式
+        output_file = getattr(args, 'output', None)
         list_keywords(
             output_format=args.format,
             name_filter=args.filter,
-            category_filter=args.category
+            category_filter=args.category,
+            output_file=output_file
         )
     elif args.command == 'run-compat':
         # 向后兼容：默认执行DSL测试
@@ -453,5 +496,38 @@ def main():
         sys.exit(1)
 
 
+def main_list_keywords():
+    """关键字列表命令的专用入口点"""
+    parser = argparse.ArgumentParser(description='查看pytest-dsl可用关键字列表')
+    parser.add_argument(
+        '--format', choices=['text', 'json'],
+        default='json',
+        help='输出格式：json(默认) 或 text'
+    )
+    parser.add_argument(
+        '--output', '-o', type=str, default=None,
+        help='输出文件路径（仅对 json 格式有效，默认为 keywords.json）'
+    )
+    parser.add_argument(
+        '--filter', type=str, default=None,
+        help='过滤关键字名称（支持部分匹配）'
+    )
+    parser.add_argument(
+        '--category',
+        choices=['builtin', 'custom', 'remote', 'all'],
+        default='all',
+        help='关键字类别：builtin(内置)、custom(自定义)、remote(远程)、all(全部，默认)'
+    )
+
+    args = parser.parse_args()
+
+    list_keywords(
+        output_format=args.format,
+        name_filter=args.filter,
+        category_filter=args.category,
+        output_file=args.output
+    )
+
+
 if __name__ == '__main__':
     main()

pytest_dsl/core/keyword_manager.py

@@ -1,13 +1,14 @@
-from typing import Dict, Any, Callable, List
+from typing import Dict, Any, Callable, List, Optional
 import functools
 import allure
 
 
 class Parameter:
-    def __init__(self, name: str, mapping: str, description: str):
+    def __init__(self, name: str, mapping: str, description: str, default: Any = None):
         self.name = name
         self.mapping = mapping
         self.description = description
+        self.default = default
 
 
 class KeywordManager:
@@ -34,6 +35,7 @@ class KeywordManager:
 
             param_list = [Parameter(**p) for p in parameters]
             mapping = {p.name: p.mapping for p in param_list}
+            defaults = {p.mapping: p.default for p in param_list if p.default is not None}
             
             # 自动添加 step_name 到 mapping 中
             mapping["步骤名称"] = "step_name"
@@ -41,7 +43,8 @@ class KeywordManager:
             self._keywords[name] = {
                 'func': wrapper,
                 'mapping': mapping,
-                'parameters': param_list
+                'parameters': param_list,
+                'defaults': defaults  # 存储默认值
             }
             return wrapper
         return decorator
@@ -51,7 +54,19 @@ class KeywordManager:
         keyword_info = self._keywords.get(keyword_name)
         if not keyword_info:
             raise KeyError(f"未注册的关键字: {keyword_name}")
-        return keyword_info['func'](**params)
+        
+        # 应用默认值
+        final_params = {}
+        defaults = keyword_info.get('defaults', {})
+        
+        # 首先设置所有默认值
+        for param_key, default_value in defaults.items():
+            final_params[param_key] = default_value
+        
+        # 然后用传入的参数覆盖默认值
+        final_params.update(params)
+        
+        return keyword_info['func'](**final_params)
 
     def get_keyword_info(self, keyword_name: str) -> Dict:
         """获取关键字信息"""
@@ -99,8 +114,9 @@ class KeywordManager:
                     description="自定义的步骤名称，用于在报告中显示"
                 ))
             for param in info['parameters']:
+                default_info = f" (默认值: {param.default})" if param.default is not None else ""
                 docs.append(
-                    f"  {param.name} ({param.mapping}): {param.description}")
+                    f"  {param.name} ({param.mapping}): {param.description}{default_info}")
             docs.append("")
         return "\n".join(docs)
 

pytest_dsl/keywords/assertion_keywords.py

@@ -48,7 +48,8 @@ def _compare_values(actual: Any, expected: Any, operator: str = "==") -> bool:
     Args:
         actual: 实际值
         expected: 预期值
-        operator: 比较运算符 (==, !=, >, <, >=, <=, contains, not_contains, matches, and, or, not)
+        operator: 比较运算符 (==, !=, >, <, >=, <=, contains, not_contains, 
+                 matches, and, or, not)
 
     Returns:
         比较结果 (True/False)
@@ -96,8 +97,9 @@ def _compare_values(actual: Any, expected: Any, operator: str = "==") -> bool:
 
 
 @keyword_manager.register('断言', [
-    {'name': '条件', 'mapping': 'condition', 'description': '断言条件表达式，例如: "${value} == 100" 或 "1 + 1 == 2"'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '条件', 'mapping': 'condition', 
+     'description': '断言条件表达式，例如: "${value} == 100" 或 "1 + 1 == 2"'},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': '断言失败'},
 ])
 def assert_condition(**kwargs):
     """执行表达式断言
@@ -116,9 +118,11 @@ def assert_condition(**kwargs):
     message = kwargs.get('message', '断言失败')
     context = kwargs.get('context')
 
-    # 简单解析表达式，支持 ==, !=, >, <, >=, <=, contains, not_contains, matches, in, and, or, not
+    # 简单解析表达式，支持 ==, !=, >, <, >=, <=, contains, not_contains, 
+    # matches, in, and, or, not
     # 格式: "left_value operator right_value" 或 "boolean_expression"
-    operators = ["==", "!=", ">", "<", ">=", "<=", "contains", "not_contains", "matches", "in", "and", "or", "not"]
+    operators = ["==", "!=", ">", "<", ">=", "<=", "contains", "not_contains", 
+                 "matches", "in", "and", "or", "not"]
 
     # 先检查是否包含这些操作符
     operator_used = None
@@ -132,7 +136,8 @@ def assert_condition(**kwargs):
         try:
             # 对条件进行变量替换
             if '${' in condition:
-                condition = context.executor.variable_replacer.replace_in_string(condition)
+                condition = context.executor.variable_replacer.replace_in_string(
+                    condition)
             # 尝试直接求值
             result = eval(condition)
             if not isinstance(result, bool):
@@ -141,7 +146,8 @@ def assert_condition(**kwargs):
                 raise AssertionError(f"{message}. 布尔表达式求值为假: {condition}")
             return True
         except Exception as e:
-            raise AssertionError(f"{message}. 无法解析条件表达式: {condition}. 错误: {str(e)}")
+            raise AssertionError(
+                f"{message}. 无法解析条件表达式: {condition}. 错误: {str(e)}")
 
     # 解析左值和右值
     left_value, right_value = condition.split(f" {operator_used} ", 1)
@@ -351,8 +357,8 @@ def assert_condition(**kwargs):
     {'name': 'JSON数据', 'mapping': 'json_data', 'description': 'JSON数据（字符串或对象）'},
     {'name': 'JSONPath', 'mapping': 'jsonpath', 'description': 'JSONPath表达式'},
     {'name': '预期值', 'mapping': 'expected_value', 'description': '预期的值'},
-    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符，默认为"=="'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符', 'default': '=='},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': 'JSON断言失败'},
 ])
 def assert_json(**kwargs):
     """执行JSON断言
@@ -476,7 +482,7 @@ def extract_json(**kwargs):
 @keyword_manager.register('类型断言', [
     {'name': '值', 'mapping': 'value', 'description': '要检查的值'},
     {'name': '类型', 'mapping': 'type', 'description': '预期的类型 (string, number, boolean, list, object, null)'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': '类型断言失败'},
 ])
 def assert_type(**kwargs):
     """断言值的类型
@@ -545,8 +551,8 @@ def assert_type(**kwargs):
 @keyword_manager.register('数据比较', [
     {'name': '实际值', 'mapping': 'actual', 'description': '实际值'},
     {'name': '预期值', 'mapping': 'expected', 'description': '预期值'},
-    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符，默认为"=="'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符', 'default': '=='},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': '数据比较失败'},
 ])
 def compare_values(**kwargs):
     """比较两个值

pytest_dsl/keywords/http_keywords.py

@@ -223,14 +223,14 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
 
 
 @keyword_manager.register('HTTP请求', [
-    {'name': '客户端', 'mapping': 'client', 'description': '客户端名称，对应YAML变量文件中的客户端配置'},
+    {'name': '客户端', 'mapping': 'client', 'description': '客户端名称，对应YAML变量文件中的客户端配置', 'default': 'default'},
     {'name': '配置', 'mapping': 'config', 'description': '包含请求、捕获和断言的YAML配置'},
     {'name': '会话', 'mapping': 'session', 'description': '会话名称，用于在多个请求间保持会话状态'},
     {'name': '保存响应', 'mapping': 'save_response', 'description': '将完整响应保存到指定变量名中'},
-    {'name': '禁用授权', 'mapping': 'disable_auth', 'description': '禁用客户端配置中的授权机制，默认为false'},
+    {'name': '禁用授权', 'mapping': 'disable_auth', 'description': '禁用客户端配置中的授权机制', 'default': False},
     {'name': '模板', 'mapping': 'template', 'description': '使用YAML变量文件中定义的请求模板'},
-    {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数'},
-    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）'}
+    {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数', 'default': 0},
+    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）', 'default': 1}
 ])
 def http_request(context, **kwargs):
     """执行HTTP请求

pytest_dsl/keywords/system_keywords.py

@@ -24,46 +24,54 @@ def return_result(**kwargs):
 
 
 @keyword_manager.register('等待', [
-    {'name': '秒数', 'mapping': 'seconds', 'description': '等待的秒数，可以是小数'}
+    {'name': '秒数', 'mapping': 'seconds', 
+     'description': '等待的秒数，可以是小数', 'default': 1}
 ])
 def wait_seconds(**kwargs):
-    """等待指定的秒数
+    """等待指定的时间
 
     Args:
-        seconds: 等待的秒数，可以是小数表示毫秒级等待
+        seconds: 等待的秒数，默认为1秒
     """
-    seconds = float(kwargs.get('seconds', 0))
+    seconds = float(kwargs.get('seconds', 1))
+    
     with allure.step(f"等待 {seconds} 秒"):
         time.sleep(seconds)
-    return True
+        allure.attach(
+            f"等待时间: {seconds} 秒",
+            name="等待完成",
+            attachment_type=allure.attachment_type.TEXT
+        )
 
 
 @keyword_manager.register('获取当前时间', [
-    {'name': '格式', 'mapping': 'format', 'description': '时间格式，例如 "%Y-%m-%d %H:%M:%S"，默认返回时间戳'},
-    {'name': '时区', 'mapping': 'timezone', 'description': '时区，例如 "Asia/Shanghai"，默认为本地时区'}
+    {'name': '格式', 'mapping': 'format', 
+     'description': '时间格式，例如 "%Y-%m-%d %H:%M:%S"', 'default': 'timestamp'},
+    {'name': '时区', 'mapping': 'timezone', 
+     'description': '时区，例如 "Asia/Shanghai"', 'default': 'Asia/Shanghai'}
 ])
 def get_current_time(**kwargs):
     """获取当前时间
 
     Args:
-        format: 时间格式，如果不提供则返回时间戳
-        timezone: 时区，默认为本地时区
+        format: 时间格式，如果设置为'timestamp'则返回时间戳
+        timezone: 时区，默认为Asia/Shanghai
 
     Returns:
-        str: 格式化的时间字符串或时间戳
+        str/float: 格式化的时间字符串或时间戳
     """
-    time_format = kwargs.get('format')
-    timezone = kwargs.get('timezone')
+    format_str = kwargs.get('format', 'timestamp')
+    timezone_str = kwargs.get('timezone', 'Asia/Shanghai')
 
     # 获取当前时间
-    if timezone:
+    if timezone_str and timezone_str != 'local':
         import pytz
         try:
-            tz = pytz.timezone(timezone)
+            tz = pytz.timezone(timezone_str)
             current_time = datetime.datetime.now(tz)
         except Exception as e:
             allure.attach(
-                f"时区设置异常: {str(e)}",
+                f"时区设置异常: {str(e)}，使用本地时区",
                 name="时区设置异常",
                 attachment_type=allure.attachment_type.TEXT
             )
@@ -72,34 +80,36 @@ def get_current_time(**kwargs):
         current_time = datetime.datetime.now()
 
     # 格式化时间
-    if time_format:
+    if format_str and format_str != 'timestamp':
         try:
-            result = current_time.strftime(time_format)
+            result = current_time.strftime(format_str)
         except Exception as e:
             allure.attach(
-                f"时间格式化异常: {str(e)}",
+                f"时间格式化异常: {str(e)}，返回默认格式",
                 name="时间格式化异常",
                 attachment_type=allure.attachment_type.TEXT
             )
-            result = str(current_time)
+            result = current_time.strftime('%Y-%m-%d %H:%M:%S')
     else:
         # 返回时间戳
-        result = str(int(current_time.timestamp()))
+        result = int(current_time.timestamp())
 
     return result
 
 
 @keyword_manager.register('生成随机字符串', [
-    {'name': '长度', 'mapping': 'length', 'description': '随机字符串的长度，默认为8'},
+    {'name': '长度', 'mapping': 'length', 
+     'description': '随机字符串的长度', 'default': 8},
     {'name': '类型', 'mapping': 'type',
-        'description': '字符类型：字母(letters)、数字(digits)、字母数字(alphanumeric)、全部(all)，默认为字母数字'}
+     'description': '字符类型：字母(letters)、数字(digits)、字母数字(alphanumeric)、全部(all)', 
+     'default': 'alphanumeric'}
 ])
 def generate_random_string(**kwargs):
-    """生成随机字符串
+    """生成指定长度和类型的随机字符串
 
     Args:
-        length: 随机字符串的长度
-        type: 字符类型：字母、数字、字母数字、全部
+        length: 字符串长度
+        type: 字符类型
 
     Returns:
         str: 生成的随机字符串
@@ -134,12 +144,15 @@ def generate_random_string(**kwargs):
 
 
 @keyword_manager.register('生成随机数', [
-    {'name': '最小值', 'mapping': 'min', 'description': '随机数的最小值，默认为0'},
-    {'name': '最大值', 'mapping': 'max', 'description': '随机数的最大值，默认为100'},
-    {'name': '小数位数', 'mapping': 'decimals', 'description': '小数位数，默认为0（整数）'}
+    {'name': '最小值', 'mapping': 'min', 
+     'description': '随机数的最小值', 'default': 0},
+    {'name': '最大值', 'mapping': 'max', 
+     'description': '随机数的最大值', 'default': 100},
+    {'name': '小数位数', 'mapping': 'decimals', 
+     'description': '小数位数，0表示整数', 'default': 0}
 ])
 def generate_random_number(**kwargs):
-    """生成随机数
+    """生成指定范围内的随机数
 
     Args:
         min: 随机数的最小值
@@ -172,24 +185,27 @@ def generate_random_number(**kwargs):
 
 @keyword_manager.register('字符串操作', [
     {'name': '操作', 'mapping': 'operation',
-        'description': '操作类型：拼接(concat)、替换(replace)、分割(split)、大写(upper)、小写(lower)、去空格(strip)'},
+     'description': '操作类型：拼接(concat)、替换(replace)、分割(split)、大写(upper)、小写(lower)、去空格(strip)', 
+     'default': 'strip'},
     {'name': '字符串', 'mapping': 'string', 'description': '要操作的字符串'},
-    {'name': '参数1', 'mapping': 'param1', 'description': '操作参数1，根据操作类型不同而不同'},
-    {'name': '参数2', 'mapping': 'param2', 'description': '操作参数2，根据操作类型不同而不同'}
+    {'name': '参数1', 'mapping': 'param1', 
+     'description': '操作参数1，根据操作类型不同而不同', 'default': ''},
+    {'name': '参数2', 'mapping': 'param2', 
+     'description': '操作参数2，根据操作类型不同而不同', 'default': ''}
 ])
 def string_operation(**kwargs):
     """字符串操作
 
     Args:
-        operation: 操作类型
+        operation: 操作类型，默认为strip（去空格）
         string: 要操作的字符串
-        param1: 操作参数1
-        param2: 操作参数2
+        param1: 操作参数1，默认为空字符串
+        param2: 操作参数2，默认为空字符串
 
     Returns:
         str: 操作结果
     """
-    operation = kwargs.get('operation', '').lower()
+    operation = kwargs.get('operation', 'strip').lower()
     string = str(kwargs.get('string', ''))
     param1 = kwargs.get('param1', '')
     param2 = kwargs.get('param2', '')
@@ -204,12 +220,16 @@ def string_operation(**kwargs):
         result = string.replace(str(param1), str(param2))
     elif operation == 'split':
         # 分割字符串
-        result = string.split(str(param1))
-        if param2 and param2.isdigit():
-            # 如果提供了索引，返回指定位置的元素
-            index = int(param2)
-            if 0 <= index < len(result):
-                result = result[index]
+        if param1:  # 如果提供了分隔符
+            result = string.split(str(param1))
+            if param2 and param2.isdigit():
+                # 如果提供了索引，返回指定位置的元素
+                index = int(param2)
+                if 0 <= index < len(result):
+                    result = result[index]
+        else:
+            # 默认按空格分割
+            result = string.split()
     elif operation == 'upper':
         # 转大写
         result = string.upper()
@@ -217,19 +237,21 @@ def string_operation(**kwargs):
         # 转小写
         result = string.lower()
     elif operation == 'strip':
-        # 去空格
+        # 去空格（默认操作）
         result = string.strip()
     else:
         # 未知操作，返回原字符串
         allure.attach(
-            f"未知的字符串操作: {operation}",
+            f"未知的字符串操作: {operation}，使用默认操作strip",
             name="字符串操作错误",
             attachment_type=allure.attachment_type.TEXT
         )
+        result = string.strip()
 
     with allure.step(f"字符串操作: {operation}"):
         allure.attach(
-            f"原字符串: {string}\n操作: {operation}\n参数1: {param1}\n参数2: {param2}\n结果: {result}",
+            f"原字符串: {string}\n操作: {operation}\n参数1: {param1}\n"
+            f"参数2: {param2}\n结果: {result}",
             name="字符串操作结果",
             attachment_type=allure.attachment_type.TEXT
         )
@@ -239,7 +261,8 @@ def string_operation(**kwargs):
 
 @keyword_manager.register('日志', [
     {'name': '级别', 'mapping': 'level',
-        'description': '日志级别：DEBUG, INFO, WARNING, ERROR, CRITICAL，默认为INFO'},
+     'description': '日志级别：DEBUG, INFO, WARNING, ERROR, CRITICAL', 
+     'default': 'INFO'},
     {'name': '消息', 'mapping': 'message', 'description': '日志消息内容'}
 ])
 def log_message(**kwargs):
@@ -270,8 +293,10 @@ def log_message(**kwargs):
 
 @keyword_manager.register('执行命令', [
     {'name': '命令', 'mapping': 'command', 'description': '要执行的系统命令'},
-    {'name': '超时', 'mapping': 'timeout', 'description': '命令执行超时时间（秒），默认为60秒'},
-    {'name': '捕获输出', 'mapping': 'capture_output', 'description': '是否捕获命令输出，默认为True'}
+    {'name': '超时', 'mapping': 'timeout', 
+     'description': '命令执行超时时间（秒）', 'default': 60},
+    {'name': '捕获输出', 'mapping': 'capture_output', 
+     'description': '是否捕获命令输出', 'default': True}
 ])
 def execute_command(**kwargs):
     """执行系统命令

pytest_dsl/remote/__init__.py

@@ -0,0 +1,7 @@
+"""
+Remote module for pytest-dsl.
+
+This module provides remote keyword server functionality.
+"""
+
+__version__ = "0.9.0"