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

pytest_dsl/core/custom_keyword_manager.py

@@ -1,11 +1,8 @@
-from typing import Dict, Any, List, Optional
 import os
-import pathlib
 from pytest_dsl.core.lexer import get_lexer
 from pytest_dsl.core.parser import get_parser, Node
 from pytest_dsl.core.dsl_executor import DSLExecutor
 from pytest_dsl.core.keyword_manager import keyword_manager
-from pytest_dsl.core.context import TestContext
 
 
 class CustomKeywordManager:
@@ -127,7 +124,7 @@ class CustomKeywordManager:
             return
 
         for node in statements_node.children:
-            if node.type == 'CustomKeyword':
+            if node.type in ['CustomKeyword', 'Function']:
                 self._register_custom_keyword(node, file_path)
 
     def _register_custom_keyword(self, node: Node, file_path: str) -> None:

pytest_dsl/core/http_client.py

@@ -132,7 +132,7 @@ class HTTPClient:
             request_kwargs = self.auth_provider.pre_request_hook(method, url, request_kwargs)
 
         # 记录请求详情
-        logger.debug(f"=== HTTP请求详情 ===")
+        logger.debug("=== HTTP请求详情 ===")
         logger.debug(f"方法: {method}")
         logger.debug(f"URL: {url}")
         if 'headers' in request_kwargs:
@@ -171,7 +171,7 @@ class HTTPClient:
                 response = requests.request(method, url, **request_kwargs)
 
             # 记录响应详情
-            logger.debug(f"\n=== HTTP响应详情 ===")
+            logger.debug("\n=== HTTP响应详情 ===")
             logger.debug(f"状态码: {response.status_code}")
             logger.debug(f"响应头: {json.dumps(dict(response.headers), indent=2, ensure_ascii=False)}")
             try:

pytest_dsl/core/keyword_manager.py

@@ -16,8 +16,14 @@ class KeywordManager:
         self._keywords: Dict[str, Dict] = {}
         self.current_context = None
 
-    def register(self, name: str, parameters: List[Dict]):
-        """关键字注册装饰器"""
+    def register(self, name: str, parameters: List[Dict], source_info: Optional[Dict] = None):
+        """关键字注册装饰器
+        
+        Args:
+            name: 关键字名称
+            parameters: 参数列表
+            source_info: 来源信息，包含 source_type, source_name, module_name 等
+        """
         def decorator(func: Callable) -> Callable:
             @functools.wraps(func)
             def wrapper(**kwargs):
@@ -40,15 +46,71 @@ class KeywordManager:
             # 自动添加 step_name 到 mapping 中
             mapping["步骤名称"] = "step_name"
             
-            self._keywords[name] = {
+            # 构建关键字信息，包含来源信息
+            keyword_info = {
                 'func': wrapper,
                 'mapping': mapping,
                 'parameters': param_list,
                 'defaults': defaults  # 存储默认值
             }
+            
+            # 添加来源信息
+            if source_info:
+                keyword_info.update(source_info)
+            else:
+                # 尝试从函数模块推断来源信息
+                keyword_info.update(self._infer_source_info(func))
+            
+            self._keywords[name] = keyword_info
             return wrapper
         return decorator
 
+    def _infer_source_info(self, func: Callable) -> Dict:
+        """从函数推断来源信息"""
+        source_info = {}
+        
+        if hasattr(func, '__module__'):
+            module_name = func.__module__
+            source_info['module_name'] = module_name
+            
+            if module_name.startswith('pytest_dsl.keywords'):
+                # 内置关键字
+                source_info['source_type'] = 'builtin'
+                source_info['source_name'] = 'pytest-dsl内置'
+            elif 'pytest_dsl' in module_name:
+                # pytest-dsl相关但不是内置的
+                source_info['source_type'] = 'internal'
+                source_info['source_name'] = 'pytest-dsl'
+            else:
+                # 第三方插件或用户自定义
+                source_info['source_type'] = 'external'
+                # 提取可能的包名
+                parts = module_name.split('.')
+                if len(parts) > 1:
+                    source_info['source_name'] = parts[0]
+                else:
+                    source_info['source_name'] = module_name
+        
+        return source_info
+
+    def register_with_source(self, name: str, parameters: List[Dict], 
+                           source_type: str, source_name: str, **kwargs):
+        """带来源信息的关键字注册装饰器
+        
+        Args:
+            name: 关键字名称
+            parameters: 参数列表
+            source_type: 来源类型 (builtin, plugin, local, remote, project_custom)
+            source_name: 来源名称 (插件名、文件路径等)
+            **kwargs: 其他来源相关信息
+        """
+        source_info = {
+            'source_type': source_type,
+            'source_name': source_name,
+            **kwargs
+        }
+        return self.register(name, parameters, source_info)
+
     def execute(self, keyword_name: str, **params: Any) -> Any:
         """执行关键字"""
         keyword_info = self._keywords.get(keyword_name)
@@ -84,6 +146,18 @@ class KeywordManager:
             
         return keyword_info
 
+    def get_keywords_by_source(self) -> Dict[str, List[str]]:
+        """按来源分组获取关键字"""
+        by_source = {}
+        
+        for name, info in self._keywords.items():
+            source_name = info.get('source_name', '未知来源')
+            if source_name not in by_source:
+                by_source[source_name] = []
+            by_source[source_name].append(name)
+        
+        return by_source
+
     def _log_execution(self, keyword_name: str, params: Dict, result: Any) -> None:
         """记录关键字执行结果"""
         allure.attach(

pytest_dsl/core/plugin_discovery.py

@@ -62,7 +62,28 @@ def load_plugin_keywords(plugin_name: str) -> None:
         
         # 如果插件有register_keywords函数，调用它
         if hasattr(plugin, 'register_keywords') and callable(plugin.register_keywords):
-            plugin.register_keywords(keyword_manager)
+            # 创建一个包装的关键字管理器，自动添加来源信息
+            class PluginKeywordManager:
+                def __init__(self, original_manager, plugin_name):
+                    self.original_manager = original_manager
+                    self.plugin_name = plugin_name
+                
+                def register(self, name: str, parameters):
+                    """带插件来源信息的注册方法"""
+                    return self.original_manager.register_with_source(
+                        name, parameters, 
+                        source_type='plugin',
+                        source_name=plugin_name,
+                        module_name=plugin_name
+                    )
+                
+                def __getattr__(self, name):
+                    # 代理其他方法到原始管理器
+                    return getattr(self.original_manager, name)
+            
+            plugin_manager = PluginKeywordManager(keyword_manager, plugin_name)
+            plugin.register_keywords(plugin_manager)
+            print(f"通过register_keywords加载插件: {plugin_name}")
             return
         
         # 否则，遍历包中的所有模块
@@ -71,13 +92,29 @@ def load_plugin_keywords(plugin_name: str) -> None:
                 if not is_pkg:
                     try:
                         module = importlib.import_module(name)
+                        print(f"加载插件模块: {name}")
                         # 模块已导入，关键字装饰器会自动注册
+                        # 但我们需要在导入后更新来源信息
+                        _update_keywords_source_info(plugin_name, name)
                     except ImportError as e:
                         print(f"无法导入模块 {name}: {e}")
     except ImportError as e:
         print(f"无法导入插件 {plugin_name}: {e}")
 
 
+def _update_keywords_source_info(plugin_name: str, module_name: str):
+    """更新模块中关键字的来源信息"""
+    # 找到可能是新注册的关键字
+    for keyword_name, keyword_info in keyword_manager._keywords.items():
+        if keyword_info.get('module_name') == module_name:
+            # 更新来源信息
+            keyword_info.update({
+                'source_type': 'plugin',
+                'source_name': plugin_name,
+                'plugin_module': module_name
+            })
+
+
 def load_all_plugins() -> None:
     """
     发现并加载所有已安装的关键字插件

pytest_dsl/keywords/http_keywords.py

@@ -20,7 +20,10 @@ from pytest_dsl.core.context import TestContext
 # 配置日志
 logger = logging.getLogger(__name__)
 
-def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: bool = True, test_context: TestContext = None) -> Any:
+
+def _process_file_reference(reference: Union[str, Dict[str, Any]],
+                            allow_vars: bool = True,
+                            test_context: TestContext = None) -> Any:
     """处理文件引用，加载外部文件内容
 
     支持两种语法:
@@ -43,7 +46,8 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
         if match:
             file_path = match.group(1).strip()
             is_template = '_template' in reference[:15]  # 检查是否为模板
-            return _load_file_content(file_path, is_template, 'auto', 'utf-8', test_context)
+            return _load_file_content(file_path, is_template, 'auto', 'utf-8',
+                                      test_context)
 
     # 处理详细语法
     elif isinstance(reference, dict) and 'file_ref' in reference:
@@ -51,7 +55,8 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
 
         if isinstance(file_ref, str):
             # 如果file_ref是字符串，使用默认配置
-            return _load_file_content(file_ref, allow_vars, 'auto', 'utf-8', test_context)
+            return _load_file_content(file_ref, allow_vars, 'auto', 'utf-8',
+                                      test_context)
         elif isinstance(file_ref, dict):
             # 如果file_ref是字典，使用自定义配置
             file_path = file_ref.get('path')
@@ -62,14 +67,16 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
             file_type = file_ref.get('type', 'auto')
             encoding = file_ref.get('encoding', 'utf-8')
 
-            return _load_file_content(file_path, template, file_type, encoding, test_context)
+            return _load_file_content(file_path, template, file_type, encoding,
+                                      test_context)
 
     # 如果不是文件引用，返回原始值
     return reference
 
 
 def _load_file_content(file_path: str, is_template: bool = False,
-                       file_type: str = 'auto', encoding: str = 'utf-8', test_context: TestContext = None) -> Any:
+                       file_type: str = 'auto', encoding: str = 'utf-8',
+                       test_context: TestContext = None) -> Any:
     """加载文件内容
 
     Args:
@@ -122,7 +129,8 @@ def _load_file_content(file_path: str, is_template: bool = False,
         return content
 
 
-def _process_request_config(config: Dict[str, Any], test_context: TestContext = None) -> Dict[str, Any]:
+def _process_request_config(config: Dict[str, Any],
+                            test_context: TestContext = None) -> Dict[str, Any]:
     """处理请求配置，检查并处理文件引用
 
     Args:
@@ -140,20 +148,24 @@ def _process_request_config(config: Dict[str, Any], test_context: TestContext =
 
         # 处理json字段
         if 'json' in request:
-            request['json'] = _process_file_reference(request['json'], test_context=test_context)
+            request['json'] = _process_file_reference(
+                request['json'], test_context=test_context)
 
         # 处理data字段
         if 'data' in request:
-            request['data'] = _process_file_reference(request['data'], test_context=test_context)
+            request['data'] = _process_file_reference(
+                request['data'], test_context=test_context)
 
         # 处理headers字段
         if 'headers' in request:
-            request['headers'] = _process_file_reference(request['headers'], test_context=test_context)
+            request['headers'] = _process_file_reference(
+                request['headers'], test_context=test_context)
 
     return config
 
 
-def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interval=None):
+def _normalize_retry_config(config, assert_retry_count=None,
+                            assert_retry_interval=None):
     """标准化断言重试配置
 
     将不同来源的重试配置（命令行参数、retry配置、retry_assertions配置）
@@ -223,14 +235,23 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
 
 
 @keyword_manager.register('HTTP请求', [
-    {'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': '禁用客户端配置中的授权机制', 'default': False},
-    {'name': '模板', 'mapping': 'template', 'description': '使用YAML变量文件中定义的请求模板'},
-    {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数', 'default': 0},
-    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）', 'default': 1}
+    {'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': '禁用客户端配置中的授权机制', 'default': False},
+    {'name': '模板', 'mapping': 'template',
+     'description': '使用YAML变量文件中定义的请求模板'},
+    {'name': '断言重试次数', 'mapping': 'assert_retry_count',
+     'description': '断言失败时的重试次数', 'default': 0},
+    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval',
+     'description': '断言重试间隔时间（秒）', 'default': 1}
 ])
 def http_request(context, **kwargs):
     """执行HTTP请求
@@ -260,7 +281,26 @@ def http_request(context, **kwargs):
     assert_retry_count = kwargs.get('assert_retry_count')
     assert_retry_interval = kwargs.get('assert_retry_interval')
 
-    with allure.step(f"发送HTTP请求 (客户端: {client_name}{', 会话: ' + session_name if session_name else ''})"):
+    # 添加调试信息，检查客户端配置是否可用
+    print(f"🌐 HTTP请求 - 客户端: {client_name}")
+
+    # 检查YAML变量中的http_clients配置（现在包含同步的变量）
+    http_clients_config = yaml_vars.get_variable("http_clients")
+    if http_clients_config:
+        print(f"✓ 找到http_clients配置，包含 {len(http_clients_config)} 个客户端")
+        if client_name in http_clients_config:
+            print(f"✓ 找到客户端 '{client_name}' 的配置")
+            client_config = http_clients_config[client_name]
+            print(f"  - base_url: {client_config.get('base_url', 'N/A')}")
+            print(f"  - timeout: {client_config.get('timeout', 'N/A')}")
+        else:
+            print(f"⚠️ 未找到客户端 '{client_name}' 的配置")
+            print(f"  可用客户端: {list(http_clients_config.keys())}")
+    else:
+        print("⚠️ 未找到http_clients配置")
+
+    with allure.step(f"发送HTTP请求 (客户端: {client_name}"
+                     f"{', 会话: ' + session_name if session_name else ''})"):
         # 处理模板
         if template_name:
             # 从YAML变量中获取模板
@@ -299,7 +339,8 @@ def http_request(context, **kwargs):
                 raise ValueError(f"无效的YAML配置: {str(e)}")
 
         # 统一处理重试配置
-        retry_config = _normalize_retry_config(config, assert_retry_count, assert_retry_interval)
+        retry_config = _normalize_retry_config(config, assert_retry_count,
+                                               assert_retry_interval)
 
         # 为了兼容性，将标准化后的重试配置写回到配置中
         if retry_config['enabled']:
@@ -344,7 +385,8 @@ def http_request(context, **kwargs):
         if session_name:
             try:
                 from pytest_dsl.core.http_client import http_client_manager
-                session_client = http_client_manager.get_session(session_name, client_name)
+                session_client = http_client_manager.get_session(
+                    session_name, client_name)
                 if session_client and session_client._session:
                     session_state = {
                         "cookies": dict(session_client._session.cookies),
@@ -375,7 +417,8 @@ def http_request(context, **kwargs):
         return {
             "result": captured_values,  # 主要返回值保持兼容
             "captures": captured_values,  # 明确的捕获变量
-            "session_state": {session_name: session_state} if session_state else {},
+            "session_state": ({session_name: session_state}
+                              if session_state else {}),
             "response": response_data,  # 完整响应（如果需要）
             "metadata": {
                 "response_time": getattr(response, 'elapsed', None),
@@ -396,7 +439,8 @@ def _deep_merge(dict1, dict2):
         合并后的字典
     """
     for key in dict2:
-        if key in dict1 and isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
+        if (key in dict1 and isinstance(dict1[key], dict) and
+                isinstance(dict2[key], dict)):
             _deep_merge(dict1[key], dict2[key])
         else:
             dict1[key] = dict2[key]
@@ -424,7 +468,8 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         )
 
         # 添加一个特殊的标记到配置中，表示我们只想收集失败的断言而不抛出异常
-        original_config = http_req.config.copy() if isinstance(http_req.config, dict) else {}
+        original_config = (http_req.config.copy()
+                           if isinstance(http_req.config, dict) else {})
 
         # 创建一个临时副本
         temp_config = original_config.copy()
@@ -442,7 +487,8 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         except Exception as collect_err:
             # 出现意外错误时记录
             allure.attach(
-                f"收集失败断言时出错: {type(collect_err).__name__}: {str(collect_err)}",
+                f"收集失败断言时出错: {type(collect_err).__name__}: "
+                f"{str(collect_err)}",
                 name="断言收集错误",
                 attachment_type=allure.attachment_type.TEXT
             )
@@ -513,16 +559,18 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
 
         # 找出所有断言中最大的重试次数
         for retryable_assertion in retryable_assertions:
-            max_retry_count = max(max_retry_count, retryable_assertion.get('retry_count', 3))
+            max_retry_count = max(max_retry_count,
+                                  retryable_assertion.get('retry_count', 3))
 
         # 进行断言重试
-        for attempt in range(1, max_retry_count + 1):  # 从1开始，因为第0次已经尝试过了
+        for attempt in range(1, max_retry_count + 1):
             # 等待重试间隔
             with allure.step(f"断言重试 (尝试 {attempt}/{max_retry_count})"):
                 # 确定本次重试的间隔时间（使用每个断言中最长的间隔时间）
                 retry_interval = retry_config['interval']
                 for assertion in retryable_assertions:
-                    retry_interval = max(retry_interval, assertion.get('retry_interval', 1.0))
+                    retry_interval = max(retry_interval,
+                                         assertion.get('retry_interval', 1.0))
 
                 allure.attach(
                     f"重试 {len(retryable_assertions)} 个断言\n"
@@ -552,14 +600,21 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
                 # 只重试那些仍在重试范围内的断言
                 try:
                     # 从原始断言配置中提取出需要重试的断言
-                    retry_assertion_indexes = [a['index'] for a in still_retryable_assertions]
-                    retry_assertions = [http_req.config.get('asserts', [])[idx] for idx in retry_assertion_indexes]
+                    retry_assertion_indexes = [
+                        a['index'] for a in still_retryable_assertions]
+                    retry_assertions = [
+                        http_req.config.get('asserts', [])[idx]
+                        for idx in retry_assertion_indexes]
 
                     # 创建索引映射：新索引 -> 原始索引
-                    index_mapping = {new_idx: orig_idx for new_idx, orig_idx in enumerate(retry_assertion_indexes)}
+                    index_mapping = {
+                        new_idx: orig_idx for new_idx, orig_idx in
+                        enumerate(retry_assertion_indexes)}
 
                     # 只处理需要重试的断言，传递索引映射
-                    results, new_failed_assertions = http_req.process_asserts(specific_asserts=retry_assertions, index_mapping=index_mapping)
+                    results, new_failed_assertions = http_req.process_asserts(
+                        specific_asserts=retry_assertions,
+                        index_mapping=index_mapping)
 
                     # 如果所有断言都通过了，检查全部断言
                     if not new_failed_assertions:
@@ -607,7 +662,8 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         except AssertionError as final_err:
             # 重新格式化错误消息，添加重试信息
             enhanced_error = (
-                f"断言验证失败 (已重试 {max_retry_count} 次):\n\n{str(final_err)}"
+                f"断言验证失败 (已重试 {max_retry_count} 次):\n\n"
+                f"{str(final_err)}"
             )
             allure.attach(
                 enhanced_error,
@@ -617,4 +673,4 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
             raise AssertionError(enhanced_error) from final_err
 
 
-# 注意：旧的重试函数已被移除，现在使用统一的重试机制
+# 注意：旧的重试函数已被移除，现在使用统一的重试机制

pytest_dsl/remote/keyword_client.py

@@ -7,16 +7,19 @@ from pytest_dsl.core.keyword_manager import keyword_manager, Parameter
 # 配置日志
 logger = logging.getLogger(__name__)
 
+
 class RemoteKeywordClient:
     """远程关键字客户端，用于连接远程关键字服务器并执行关键字"""
 
-    def __init__(self, url='http://localhost:8270/', api_key=None, alias=None, sync_config=None):
+    def __init__(self, url='http://localhost:8270/', api_key=None, alias=None,
+                 sync_config=None):
         self.url = url
         self.server = xmlrpc.client.ServerProxy(url, allow_none=True)
         self.keyword_cache = {}
         self.param_mappings = {}  # 存储每个关键字的参数映射
         self.api_key = api_key
-        self.alias = alias or url.replace('http://', '').replace('https://', '').split(':')[0]
+        self.alias = alias or url.replace('http://', '').replace(
+            'https://', '').split(':')[0]
 
         # 变量传递配置（简化版）
         self.sync_config = sync_config or {
@@ -24,7 +27,6 @@ class RemoteKeywordClient:
             'sync_yaml_vars': True,     # 连接时传递YAML配置变量
             'yaml_sync_keys': None,     # 指定要同步的YAML键列表，None表示同步所有（除了排除的）
             'yaml_exclude_patterns': [  # 排除包含这些模式的YAML变量
-                'password', 'secret', 'key', 'token', 'credential', 'auth',
                 'private', 'remote_servers'  # 排除远程服务器配置避免循环
             ]
         }
@@ -42,7 +44,8 @@ class RemoteKeywordClient:
             self._send_initial_variables()
 
             logger.info(f"已连接到远程关键字服务器: {self.url}, 别名: {self.alias}")
-            print(f"RemoteKeywordClient: 成功连接到远程服务器 {self.url}, 别名: {self.alias}")
+            print(f"RemoteKeywordClient: 成功连接到远程服务器 {self.url}, "
+                  f"别名: {self.alias}")
             return True
         except Exception as e:
             error_msg = f"连接远程关键字服务器失败: {str(e)}"
@@ -81,7 +84,8 @@ class RemoteKeywordClient:
             for param_detail in param_details:
                 param_name = param_detail['name']
                 param_mapping_name = param_detail.get('mapping', param_name)
-                param_desc = param_detail.get('description', f'远程关键字参数: {param_name}')
+                param_desc = param_detail.get('description',
+                                              f'远程关键字参数: {param_name}')
                 param_default = param_detail.get('default')
                 
                 # 确保参数名称正确映射
@@ -114,7 +118,8 @@ class RemoteKeywordClient:
                 'func': remote_func,
                 'mapping': {p['name']: p['mapping'] for p in parameters},
                 'parameters': [Parameter(**p) for p in parameters],
-                'defaults': {p['mapping']: p['default'] for p in parameters if p['default'] is not None},  # 添加默认值支持
+                'defaults': {p['mapping']: p['default'] for p in parameters
+                           if p['default'] is not None},  # 添加默认值支持
                 'remote': True,  # 标记为远程关键字
                 'alias': self.alias,
                 'original_name': name
@@ -161,7 +166,7 @@ class RemoteKeywordClient:
         else:
             # 如果没有任何映射，使用原始参数名
             param_mapping = None
-            print(f"没有找到参数映射，使用原始参数名")
+            print("没有找到参数映射，使用原始参数名")
 
         # 映射参数名称
         mapped_kwargs = {}
@@ -209,10 +214,11 @@ class RemoteKeywordClient:
 
                 # 处理响应数据
                 if 'response' in return_data and return_data['response']:
-                    print(f"远程关键字响应数据: 已接收")
+                    print("远程关键字响应数据: 已接收")
 
                 # 检查是否为新的统一返回格式（包含captures等字段）
-                if 'captures' in return_data or 'session_state' in return_data or 'metadata' in return_data:
+                if ('captures' in return_data or 'session_state' in return_data or
+                        'metadata' in return_data):
                     # 返回完整的新格式，让DSL执行器处理变量捕获
                     return return_data
                 elif 'result' in return_data:
@@ -243,11 +249,13 @@ class RemoteKeywordClient:
             if variables_to_send:
                 try:
                     # 调用远程服务器的变量接收接口
-                    result = self.server.sync_variables_from_client(variables_to_send, self.api_key)
+                    result = self.server.sync_variables_from_client(
+                        variables_to_send, self.api_key)
                     if result.get('status') == 'success':
                         print(f"成功传递 {len(variables_to_send)} 个变量到远程服务器")
                     else:
-                        print(f"传递变量到远程服务器失败: {result.get('error', '未知错误')}")
+                        print(f"传递变量到远程服务器失败: "
+                              f"{result.get('error', '未知错误')}")
                 except Exception as e:
                     print(f"调用远程变量接口失败: {str(e)}")
             else:
@@ -295,10 +303,12 @@ class RemoteKeywordClient:
             # 获取所有YAML变量
             yaml_data = yaml_vars._variables
             if yaml_data:
+                print(f"客户端YAML变量总数: {len(yaml_data)}")
+                
                 # 检查同步配置中是否指定了特定的键
                 sync_keys = self.sync_config.get('yaml_sync_keys', None)
                 exclude_patterns = self.sync_config.get('yaml_exclude_patterns', [
-                    'password', 'secret', 'key', 'token', 'credential', 'auth',
+                    'password', 'secret', 'token', 'credential', 'auth',
                     'private', 'remote_servers'  # 排除远程服务器配置避免循环
                 ])
 
@@ -307,6 +317,7 @@ class RemoteKeywordClient:
                     for key in sync_keys:
                         if key in yaml_data:
                             variables[key] = yaml_data[key]
+                            print(f"传递指定YAML变量: {key}")
                 else:
                     # 传递所有YAML变量，但排除敏感信息
                     for key, value in yaml_data.items():
@@ -323,7 +334,8 @@ class RemoteKeywordClient:
                         if not should_exclude and isinstance(value, str):
                             value_lower = value.lower()
                             for pattern in exclude_patterns:
-                                if pattern.lower() in value_lower and len(value) < 100:  # 只检查短字符串
+                                if (pattern.lower() in value_lower and
+                                        len(value) < 100):  # 只检查短字符串
                                     should_exclude = True
                                     break
 
@@ -336,11 +348,11 @@ class RemoteKeywordClient:
 
         except Exception as e:
             logger.warning(f"收集YAML变量失败: {str(e)}")
+            print(f"收集YAML变量失败: {str(e)}")
 
         return variables
 
 
-
 # 远程关键字客户端管理器
 class RemoteKeywordManager:
     """远程关键字客户端管理器，管理多个远程服务器连接"""
@@ -348,7 +360,8 @@ class RemoteKeywordManager:
     def __init__(self):
         self.clients = {}  # 别名 -> 客户端实例
 
-    def register_remote_server(self, url, alias, api_key=None, sync_config=None):
+    def register_remote_server(self, url, alias, api_key=None,
+                               sync_config=None):
         """注册远程关键字服务器
 
         Args:
@@ -361,7 +374,8 @@ class RemoteKeywordManager:
             bool: 是否成功连接
         """
         print(f"RemoteKeywordManager: 正在注册远程服务器 {url} 别名 {alias}")
-        client = RemoteKeywordClient(url=url, api_key=api_key, alias=alias, sync_config=sync_config)
+        client = RemoteKeywordClient(url=url, api_key=api_key, alias=alias,
+                                     sync_config=sync_config)
         success = client.connect()
 
         if success:
@@ -394,6 +408,5 @@ class RemoteKeywordManager:
         return client._execute_remote_keyword(name=keyword_name, **kwargs)
 
 
-
 # 创建全局远程关键字管理器实例
 remote_keyword_manager = RemoteKeywordManager()