pytest-dsl 0.15.3__py3-none-any.whl → 0.15.5__py3-none-any.whl

pytest_dsl/core/dsl_executor.py

@@ -34,8 +34,8 @@ class ReturnException(Exception):
 class DSLExecutionError(Exception):
     """DSL执行异常，包含行号信息"""
 
-    def __init__(self, message: str, line_number: int = None, node_type: str = None,
-                 original_exception: Exception = None):
+    def __init__(self, message: str, line_number: int = None,
+                 node_type: str = None, original_exception: Exception = None):
         self.line_number = line_number
         self.node_type = node_type
         self.original_exception = original_exception
@@ -48,7 +48,9 @@ class DSLExecutionError(Exception):
             error_parts.append(f"节点类型: {node_type}")
         if original_exception:
             error_parts.append(
-                f"原始异常: {type(original_exception).__name__}: {str(original_exception)}")
+                f"原始异常: {type(original_exception).__name__}: "
+                f"{str(original_exception)}"
+            )
 
         super().__init__(" | ".join(error_parts))
 
@@ -72,6 +74,10 @@ class DSLExecutor:
         self.variables = {}
         self.test_context = TestContext()
         self.test_context.executor = self  # 让 test_context 能够访问到 executor
+
+        # 设置变量提供者，实现YAML变量等外部变量源的注入
+        self._setup_variable_providers()
+
         self.variable_replacer = VariableReplacer(
             self.variables, self.test_context)
         self.imported_files = set()  # 跟踪已导入的文件，避免循环导入
@@ -104,7 +110,8 @@ class DSLExecutor:
         target_node = node or self._current_node
 
         # 尝试从当前节点获取行号
-        if target_node and hasattr(target_node, 'line_number') and target_node.line_number:
+        if (target_node and hasattr(target_node, 'line_number') and
+                target_node.line_number):
             return f"\n行号: {target_node.line_number}"
 
         # 如果当前节点没有行号，从节点栈中查找最近的有行号的节点
@@ -113,12 +120,16 @@ class DSLExecutor:
                 return f"\n行号: {stack_node.line_number}"
 
         # 如果当前节点没有行号，尝试从当前执行的节点获取
-        if self._current_node and hasattr(self._current_node, 'line_number') and self._current_node.line_number:
+        if (self._current_node and
+                hasattr(self._current_node, 'line_number') and
+                self._current_node.line_number):
             return f"\n行号: {self._current_node.line_number}"
 
         return ""
 
-    def _handle_exception_with_line_info(self, e: Exception, node=None, context_info: str = "", skip_allure_logging: bool = False):
+    def _handle_exception_with_line_info(self, e: Exception, node=None,
+                                         context_info: str = "",
+                                         skip_allure_logging: bool = False):
         """统一处理异常并记录行号信息
 
         Args:
@@ -275,7 +286,8 @@ class DSLExecutor:
             elif expr_node.type == 'StringLiteral':
                 # 字符串字面量，如果包含变量占位符则进行替换，否则直接返回
                 if '${' in expr_node.value:
-                    return self.variable_replacer.replace_in_string(expr_node.value)
+                    return self.variable_replacer.replace_in_string(
+                        expr_node.value)
                 else:
                     return expr_node.value
             elif expr_node.type == 'NumberLiteral':
@@ -290,7 +302,8 @@ class DSLExecutor:
                     raise KeyError(f"变量 '{var_name}' 不存在")
             elif expr_node.type == 'PlaceholderRef':
                 # 变量占位符 ${var}，进行变量替换
-                return self.variable_replacer.replace_in_string(expr_node.value)
+                return self.variable_replacer.replace_in_string(
+                    expr_node.value)
             elif expr_node.type == 'KeywordCall':
                 return self.execute(expr_node)
             elif expr_node.type == 'ListExpr':
@@ -321,7 +334,8 @@ class DSLExecutor:
             else:
                 raise Exception(f"无法求值的表达式类型: {expr_node.type}")
 
-        return self._execute_with_error_handling(_eval_expression_impl, expr_node)
+        return self._execute_with_error_handling(
+            _eval_expression_impl, expr_node)
 
     def _eval_expression_value(self, value):
         """处理表达式值的具体逻辑"""
@@ -331,8 +345,10 @@ class DSLExecutor:
             elif isinstance(value, str):
                 # 定义扩展的变量引用模式，支持数组索引和字典键访问
                 pattern = (
-                    r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*'
-                    r'(?:(?:\.[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)'
+                    r'\$\{([a-zA-Z_\u4e00-\u9fa5]'
+                    r'[a-zA-Z0-9_\u4e00-\u9fa5]*'
+                    r'(?:(?:\.[a-zA-Z_\u4e00-\u9fa5]'
+                    r'[a-zA-Z0-9_\u4e00-\u9fa5]*)'
                     r'|(?:\[[^\]]+\]))*)\}'
                 )
                 # 检查整个字符串是否完全匹配单一变量引用模式
@@ -347,8 +363,10 @@ class DSLExecutor:
                 else:
                     # 对于不包含 ${} 的普通字符串，检查是否为单纯的变量名
                     # 只有当字符串是有效的变量名格式且确实存在该变量时，才当作变量处理
-                    if (re.match(r'^[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*$', value) and
-                        value in self.variable_replacer.local_variables):
+                    var_pattern = (r'^[a-zA-Z_\u4e00-\u9fa5]'
+                                   r'[a-zA-Z0-9_\u4e00-\u9fa5]*$')
+                    if (re.match(var_pattern, value) and
+                            value in self.variable_replacer.local_variables):
                         return self.variable_replacer.local_variables[value]
                     else:
                         # 否则当作字符串字面量处理
@@ -357,7 +375,8 @@ class DSLExecutor:
         except Exception as e:
             # 为变量解析异常添加更多上下文信息
             context_info = f"解析表达式值 '{value}'"
-            self._handle_exception_with_line_info(e, context_info=context_info)
+            self._handle_exception_with_line_info(
+                e, context_info=context_info)
 
     def _eval_comparison_expr(self, expr_node):
         """
@@ -366,6 +385,7 @@ class DSLExecutor:
         :param expr_node: 比较表达式节点
         :return: 比较结果（布尔值）
         """
+        operator = "未知"  # 设置默认值，避免UnboundLocalError
         try:
             left_value = self.eval_expression(expr_node.children[0])
             right_value = self.eval_expression(expr_node.children[1])
@@ -403,6 +423,7 @@ class DSLExecutor:
         :param expr_node: 算术表达式节点
         :return: 计算结果
         """
+        operator = "未知"  # 设置默认值，避免UnboundLocalError
         try:
             left_value = self.eval_expression(expr_node.children[0])
             right_value = self.eval_expression(expr_node.children[1])
@@ -746,9 +767,15 @@ class DSLExecutor:
                         name="赋值详情",
                         attachment_type=allure.attachment_type.TEXT
                     )
+
+                # 通知远程服务器变量已更新
+                self._notify_remote_servers_variable_changed(
+                    var_name, expr_value)
+
             except Exception as e:
                 # 在步骤内部记录异常详情
-                error_details = f"执行Assignment节点: {str(e)}{line_info}\n上下文: 执行Assignment节点"
+                error_details = (f"执行Assignment节点: {str(e)}{line_info}\n"
+                                 f"上下文: 执行Assignment节点")
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -789,9 +816,15 @@ class DSLExecutor:
                         name="关键字赋值详情",
                         attachment_type=allure.attachment_type.TEXT
                     )
+
+                # 通知远程服务器变量已更新
+                self._notify_remote_servers_variable_changed(var_name, result)
+
             except Exception as e:
                 # 在步骤内部记录异常详情
-                error_details = f"执行AssignmentKeywordCall节点: {str(e)}{line_info}\n上下文: 执行AssignmentKeywordCall节点"
+                error_details = (f"执行AssignmentKeywordCall节点: {str(e)}"
+                                 f"{line_info}\n"
+                                 f"上下文: 执行AssignmentKeywordCall节点")
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -800,6 +833,51 @@ class DSLExecutor:
                 # 重新抛出异常，让外层的统一异常处理机制处理
                 raise
 
+    def _notify_remote_servers_variable_changed(self, var_name, var_value):
+        """通知远程服务器变量已发生变化
+
+        Args:
+            var_name: 变量名
+            var_value: 变量值
+        """
+        try:
+            # 使用统一的序列化工具进行变量过滤
+            from .serialization_utils import XMLRPCSerializer
+            
+            variables_to_filter = {var_name: var_value}
+            filtered_variables = XMLRPCSerializer.filter_variables(
+                variables_to_filter)
+            
+            if not filtered_variables:
+                # 变量被过滤掉了（敏感变量或不可序列化）
+                return
+
+            # 导入远程关键字管理器
+            from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
+            # 获取所有已连接的远程服务器客户端
+            for alias, client in remote_keyword_manager.clients.items():
+                try:
+                    # 调用远程服务器的变量同步接口
+                    result = client.server.sync_variables_from_client(
+                        filtered_variables, client.api_key)
+
+                    if result.get('status') == 'success':
+                        print(f"🔄 变量 {var_name} 已同步到远程服务器 {alias}")
+                    else:
+                        error_msg = result.get('error', '未知错误')
+                        print(f"❌ 变量 {var_name} 同步到远程服务器 {alias} "
+                              f"失败: {error_msg}")
+
+                except Exception as e:
+                    print(f"❌ 通知远程服务器 {alias} 变量变化失败: {str(e)}")
+
+        except ImportError:
+            # 如果没有导入远程模块，跳过通知
+            pass
+        except Exception as e:
+            print(f"❌ 通知远程服务器变量变化时发生错误: {str(e)}")
+
     def _handle_for_loop(self, node):
         """处理for循环"""
         step_name = f"执行循环: {node.value}"
@@ -828,6 +906,9 @@ class DSLExecutor:
                     self.variable_replacer.local_variables[var_name] = i
                     self.test_context.set(var_name, i)
 
+                    # 通知远程服务器循环变量已更新
+                    self._notify_remote_servers_variable_changed(var_name, i)
+
                     with allure.step(f"循环轮次: {var_name} = {i}"):
                         try:
                             self.execute(node.children[2])
@@ -857,7 +938,9 @@ class DSLExecutor:
                             raise e
                         except Exception as e:
                             # 在循环轮次内部记录异常详情
-                            error_details = f"循环执行异常 ({var_name} = {i}): {str(e)}{line_info}\n上下文: 执行ForLoop节点"
+                            error_details = (f"循环执行异常 ({var_name} = {i}): "
+                                             f"{str(e)}{line_info}\n"
+                                             f"上下文: 执行ForLoop节点")
                             allure.attach(
                                 error_details,
                                 name="DSL执行异常",
@@ -870,7 +953,8 @@ class DSLExecutor:
                 raise
             except Exception as e:
                 # 在步骤内部记录异常详情
-                error_details = f"执行ForLoop节点: {str(e)}{line_info}\n上下文: 执行ForLoop节点"
+                error_details = (f"执行ForLoop节点: {str(e)}{line_info}\n"
+                                 f"上下文: 执行ForLoop节点")
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -891,7 +975,8 @@ class DSLExecutor:
             # 在步骤内部记录异常
             with allure.step(f"调用关键字: {keyword_name}"):
                 allure.attach(
-                    f"执行KeywordCall节点: 未注册的关键字: {keyword_name}{line_info}\n上下文: 执行KeywordCall节点",
+                    f"执行KeywordCall节点: 未注册的关键字: {keyword_name}"
+                    f"{line_info}\n上下文: 执行KeywordCall节点",
                     name="DSL执行异常",
                     attachment_type=allure.attachment_type.TEXT
                 )
@@ -903,7 +988,7 @@ class DSLExecutor:
             try:
                 # 准备参数（这里可能抛出参数解析异常）
                 kwargs = self._prepare_keyword_params(node, keyword_info)
-                
+
                 # 传递自定义步骤名称给KeywordManager，避免重复的allure步骤嵌套
                 kwargs['step_name'] = keyword_name  # 内层步骤只显示关键字名称
                 # 避免KeywordManager重复记录，由DSL执行器统一记录
@@ -927,18 +1012,26 @@ class DSLExecutor:
                     if "参数解析异常" in core_error:
                         # 提取参数名和具体错误
                         import re
-                        match = re.search(r'参数解析异常 \(([^)]+)\): (.+)', core_error)
+                        match = re.search(
+                            r'参数解析异常 \(([^)]+)\): (.+)', core_error)
                         if match:
                             param_name, detailed_error = match.groups()
-                            error_details = f"参数解析失败 ({param_name}): {detailed_error}{line_info}\n上下文: 执行KeywordCall节点"
+                            error_details = (f"参数解析失败 ({param_name}): "
+                                             f"{detailed_error}{line_info}\n"
+                                             f"上下文: 执行KeywordCall节点")
                         else:
-                            error_details = f"参数解析失败: {core_error}{line_info}\n上下文: 执行KeywordCall节点"
+                            error_details = (f"参数解析失败: {core_error}"
+                                             f"{line_info}\n"
+                                             f"上下文: 执行KeywordCall节点")
                     else:
-                        error_details = f"参数解析失败: {core_error}{line_info}\n上下文: 执行KeywordCall节点"
+                        error_details = (f"参数解析失败: {core_error}"
+                                         f"{line_info}\n"
+                                         f"上下文: 执行KeywordCall节点")
                 else:
                     # 其他异常
-                    error_details = f"执行KeywordCall节点: {str(e)}{line_info}\n上下文: 执行KeywordCall节点"
-                
+                    error_details = (f"执行KeywordCall节点: {str(e)}{line_info}\n"
+                                     f"上下文: 执行KeywordCall节点")
+
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -951,21 +1044,20 @@ class DSLExecutor:
         """准备关键字调用参数"""
         mapping = keyword_info.get('mapping', {})
         kwargs = {'context': self.test_context}  # 默认传入context参数
-        line_info = self._get_line_info(node)
 
         # 检查是否有参数列表
         if node.children[0]:
             for param in node.children[0]:
                 param_name = param.value
                 english_param_name = mapping.get(param_name, param_name)
-                
+
                 # 在子步骤中处理参数值解析，但不记录异常详情
                 with allure.step(f"解析参数: {param_name}"):
                     try:
                         # 对参数值进行变量替换
                         param_value = self.eval_expression(param.children[0])
                         kwargs[english_param_name] = param_value
-                        
+
                         # 只记录参数解析成功的简要信息
                         allure.attach(
                             f"参数名: {param_name}\n"
@@ -975,7 +1067,8 @@ class DSLExecutor:
                         )
                     except Exception as e:
                         # 将异常重新包装，添加参数名信息，但不在这里记录到allure
-                        raise Exception(f"参数解析异常 ({param_name}): {str(e)}")
+                        raise Exception(
+                             f"参数解析异常 ({param_name}): {str(e)}")
 
         return kwargs
 
@@ -1104,7 +1197,8 @@ class DSLExecutor:
                 return result
             except Exception as e:
                 # 在步骤内部记录异常详情
-                error_details = f"执行RemoteKeywordCall节点: {str(e)}{line_info}\n上下文: 执行RemoteKeywordCall节点"
+                error_details = (f"执行RemoteKeywordCall节点: {str(e)}"
+                                 f"{line_info}\n上下文: 执行RemoteKeywordCall节点")
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -1144,7 +1238,8 @@ class DSLExecutor:
                             else:
                                 self.variable_replacer.local_variables[
                                     capture_var] = capture_value
-                                self.test_context.set(capture_var, capture_value)
+                                self.test_context.set(
+                                    capture_var, capture_value)
 
                         # 将主要结果赋值给指定变量
                         actual_result = main_result
@@ -1170,12 +1265,26 @@ class DSLExecutor:
                             name="远程关键字赋值",
                             attachment_type=allure.attachment_type.TEXT
                         )
+
+                    # 通知远程服务器变量已更新
+                    self._notify_remote_servers_variable_changed(
+                        var_name, actual_result)
+
+                    # 同时处理captures中的变量同步
+                    if isinstance(result, dict) and 'captures' in result:
+                        captures = result.get('captures', {})
+                        for capture_var, capture_value in captures.items():
+                            # 通知远程服务器捕获的变量也已更新
+                            self._notify_remote_servers_variable_changed(
+                                capture_var, capture_value)
                 else:
                     error_msg = "远程关键字没有返回结果"
                     raise Exception(error_msg)
             except Exception as e:
                 # 在步骤内部记录异常详情
-                error_details = f"执行AssignmentRemoteKeywordCall节点: {str(e)}{line_info}\n上下文: 执行AssignmentRemoteKeywordCall节点"
+                error_details = (f"执行AssignmentRemoteKeywordCall节点: {str(e)}"
+                                 f"{line_info}\n"
+                                 f"上下文: 执行AssignmentRemoteKeywordCall节点")
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -1249,7 +1358,8 @@ class DSLExecutor:
                 self.execution_tracker.finish_current_step(error=error_msg)
 
             # 如果是控制流异常或已经是DSLExecutionError，直接重抛
-            if isinstance(e, (BreakException, ContinueException, ReturnException, DSLExecutionError)):
+            if isinstance(e, (BreakException, ContinueException,
+                              ReturnException, DSLExecutionError)):
                 raise
 
             # 如果是断言异常，保持原样但可能添加行号信息
@@ -1265,7 +1375,7 @@ class DSLExecutor:
             # 其他异常使用统一处理机制
             # 对于这些节点类型，异常已经在步骤中记录过了，跳过重复记录
             step_handled_nodes = {
-                'KeywordCall', 'Assignment', 'AssignmentKeywordCall', 
+                'KeywordCall', 'Assignment', 'AssignmentKeywordCall',
                 'ForLoop', 'RemoteKeywordCall', 'AssignmentRemoteKeywordCall'
             }
             skip_logging = node.type in step_handled_nodes
@@ -1312,6 +1422,20 @@ class DSLExecutor:
                 f"hooks_enabled={self.enable_hooks}, "
                 f"tracking_enabled={self.enable_tracking})")
 
+    def _setup_variable_providers(self):
+        """设置变量提供者，将外部变量源注入到TestContext中"""
+        try:
+            from .variable_providers import (
+                setup_context_with_default_providers
+            )
+            setup_context_with_default_providers(self.test_context)
+
+            # 同步常用变量到context中，提高访问性能
+            self.test_context.sync_variables_from_external_sources()
+        except ImportError as e:
+            # 如果导入失败，记录警告但不影响正常功能
+            print(f"警告：无法设置变量提供者: {e}")
+
     def _init_hooks(self):
         """初始化hook机制"""
         try:

pytest_dsl/core/global_context.py

@@ -4,7 +4,6 @@ import tempfile
 import allure
 from typing import Dict, Any, Optional
 from filelock import FileLock
-from .yaml_vars import yaml_vars
 
 
 class GlobalContext:
@@ -19,6 +18,20 @@ class GlobalContext:
             self._storage_dir, "global_vars.json")
         self._lock_file = os.path.join(self._storage_dir, "global_vars.lock")
 
+        # 初始化变量提供者（延迟加载，避免循环导入）
+        self._yaml_provider = None
+
+    def _get_yaml_provider(self):
+        """延迟获取YAML变量提供者，避免循环导入"""
+        if self._yaml_provider is None:
+            try:
+                from .variable_providers import YAMLVariableProvider
+                self._yaml_provider = YAMLVariableProvider()
+            except ImportError:
+                # 如果变量提供者不可用，创建一个空的提供者
+                self._yaml_provider = _EmptyProvider()
+        return self._yaml_provider
+
     def set_variable(self, name: str, value: Any) -> None:
         """设置全局变量"""
         with FileLock(self._lock_file):
@@ -34,8 +47,9 @@ class GlobalContext:
 
     def get_variable(self, name: str) -> Any:
         """获取全局变量，优先从YAML变量中获取"""
-        # 首先尝试从YAML变量中获取
-        yaml_value = yaml_vars.get_variable(name)
+        # 首先尝试从YAML变量中获取（通过变量提供者）
+        yaml_provider = self._get_yaml_provider()
+        yaml_value = yaml_provider.get_variable(name)
         if yaml_value is not None:
             return yaml_value
 
@@ -46,8 +60,9 @@ class GlobalContext:
 
     def has_variable(self, name: str) -> bool:
         """检查全局变量是否存在（包括YAML变量）"""
-        # 首先检查YAML变量
-        if yaml_vars.get_variable(name) is not None:
+        # 首先检查YAML变量（通过变量提供者）
+        yaml_provider = self._get_yaml_provider()
+        if yaml_provider.has_variable(name):
             return True
 
         # 然后检查全局变量存储
@@ -73,9 +88,11 @@ class GlobalContext:
         """清除所有全局变量（包括YAML变量）"""
         with FileLock(self._lock_file):
             self._save_variables({})
-        
-        # 清除YAML变量
-        yaml_vars.clear()
+
+        # 清除YAML变量（通过变量提供者）
+        yaml_provider = self._get_yaml_provider()
+        if hasattr(yaml_provider, 'clear'):
+            yaml_provider.clear()
 
         allure.attach(
             "清除所有全局变量",
@@ -99,5 +116,18 @@ class GlobalContext:
             json.dump(variables, f, ensure_ascii=False, indent=2)
 
 
+class _EmptyProvider:
+    """空的变量提供者，用作后备方案"""
+
+    def get_variable(self, key: str) -> Optional[Any]:
+        return None
+
+    def has_variable(self, key: str) -> bool:
+        return False
+
+    def clear(self):
+        pass
+
+
 # 创建全局上下文管理器实例
 global_context = GlobalContext()

pytest_dsl/core/http_client.py

@@ -3,7 +3,6 @@ import logging
 from typing import Dict, Any
 import requests
 from urllib.parse import urljoin
-from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.auth_provider import create_auth_provider
 
 logger = logging.getLogger(__name__)
@@ -289,6 +288,31 @@ class HTTPClientManager:
         """初始化客户端管理器"""
         self._clients: Dict[str, HTTPClient] = {}
         self._sessions: Dict[str, HTTPClient] = {}
+        self._context = None  # 添加context引用
+
+    def set_context(self, context):
+        """设置测试上下文，用于获取HTTP客户端配置
+
+        Args:
+            context: TestContext实例
+        """
+        self._context = context
+
+    def _get_http_clients_config(self) -> Dict[str, Any]:
+        """从context获取HTTP客户端配置
+
+        Returns:
+            HTTP客户端配置字典
+        """
+        if self._context:
+            return self._context.get("http_clients") or {}
+
+        # 如果没有context，尝试从yaml_vars获取（兼容性）
+        try:
+            from pytest_dsl.core.yaml_vars import yaml_vars
+            return yaml_vars.get_variable("http_clients") or {}
+        except ImportError:
+            return {}
 
     def create_client(self, config: Dict[str, Any]) -> HTTPClient:
         """从配置创建客户端
@@ -326,8 +350,8 @@ class HTTPClientManager:
         if name in self._clients:
             return self._clients[name]
 
-        # 从YAML变量中读取客户端配置
-        http_clients = yaml_vars.get_variable("http_clients") or {}
+        # 从context获取HTTP客户端配置（统一的变量获取方式）
+        http_clients = self._get_http_clients_config()
         client_config = http_clients.get(name)
 
         if not client_config:
@@ -377,7 +401,7 @@ class HTTPClientManager:
         return session
 
     def _get_client_config(self, name: str) -> Dict[str, Any]:
-        """从YAML变量获取客户端配置
+        """从context获取客户端配置
 
         Args:
             name: 客户端名称
@@ -385,7 +409,7 @@ class HTTPClientManager:
         Returns:
             客户端配置
         """
-        http_clients = yaml_vars.get_variable("http_clients") or {}
+        http_clients = self._get_http_clients_config()
         client_config = http_clients.get(name)
 
         if not client_config and name == "default":

pytest_dsl/core/keyword_utils.py

@@ -210,6 +210,13 @@ class KeywordFormatter:
             'parameters': keyword_info.parameters
         }
 
+        # 添加来源字段，优先显示项目自定义关键字的文件位置
+        if keyword_info.file_location:
+            keyword_data['source'] = keyword_info.file_location
+        else:
+            keyword_data['source'] = keyword_info.source_info.get(
+                'display_name', keyword_info.source_info.get('name', '未知'))
+
         # 远程关键字特殊信息
         if keyword_info.remote_info:
             keyword_data['remote'] = keyword_info.remote_info