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

pytest_dsl/__init__.py

@@ -12,7 +12,7 @@ pytest-dsl - 基于pytest的DSL测试框架
 - 自定义关键字支持
 """
 
-__version__ = "0.15.4"
+__version__ = "0.15.5"
 
 # 核心执行器
 from pytest_dsl.core.dsl_executor import DSLExecutor

pytest_dsl/core/context.py

@@ -46,6 +46,29 @@ class TestContext:
         """获取所有本地变量"""
         return self._data
 
+    def get_all_context_variables(self) -> dict:
+        """获取所有上下文变量，包括本地变量和外部提供者变量
+        
+        Returns:
+            包含所有上下文变量的字典，本地变量优先级高于外部变量
+        """
+        all_variables = {}
+        
+        # 1. 先添加外部提供者的变量
+        for provider in self._external_providers:
+            if hasattr(provider, 'get_all_variables'):
+                try:
+                    external_vars = provider.get_all_variables()
+                    if isinstance(external_vars, dict):
+                        all_variables.update(external_vars)
+                except Exception as e:
+                    print(f"警告：获取外部变量提供者变量时发生错误: {e}")
+        
+        # 2. 再添加本地变量（覆盖同名的外部变量）
+        all_variables.update(self._data)
+        
+        return all_variables
+
     def register_external_variable_provider(self, provider) -> None:
         """注册外部变量提供者
 

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))
 
@@ -108,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}"
 
         # 如果当前节点没有行号，从节点栈中查找最近的有行号的节点
@@ -117,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:
@@ -279,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':
@@ -294,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':
@@ -325,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):
         """处理表达式值的具体逻辑"""
@@ -335,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'|(?:\[[^\]]+\]))*)\}'
                 )
                 # 检查整个字符串是否完全匹配单一变量引用模式
@@ -351,7 +363,9 @@ class DSLExecutor:
                 else:
                     # 对于不包含 ${} 的普通字符串，检查是否为单纯的变量名
                     # 只有当字符串是有效的变量名格式且确实存在该变量时，才当作变量处理
-                    if (re.match(r'^[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*$', value) and
+                    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:
@@ -361,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):
         """
@@ -752,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执行异常",
@@ -795,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执行异常",
@@ -806,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}"
@@ -834,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])
@@ -863,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执行异常",
@@ -876,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执行异常",
@@ -897,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
                 )
@@ -937,14 +1016,21 @@ class DSLExecutor:
                             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,
@@ -958,7 +1044,6 @@ class DSLExecutor:
         """准备关键字调用参数"""
         mapping = keyword_info.get('mapping', {})
         kwargs = {'context': self.test_context}  # 默认传入context参数
-        line_info = self._get_line_info(node)
 
         # 检查是否有参数列表
         if node.children[0]:
@@ -982,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
 
@@ -1111,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执行异常",
@@ -1178,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执行异常",
@@ -1257,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
 
             # 如果是断言异常，保持原样但可能添加行号信息
@@ -1323,7 +1425,9 @@ class DSLExecutor:
     def _setup_variable_providers(self):
         """设置变量提供者，将外部变量源注入到TestContext中"""
         try:
-            from .variable_providers import setup_context_with_default_providers
+            from .variable_providers import (
+                setup_context_with_default_providers
+            )
             setup_context_with_default_providers(self.test_context)
 
             # 同步常用变量到context中，提高访问性能

pytest_dsl/core/serialization_utils.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+序列化工具模块
+
+提供统一的XML-RPC序列化检查和转换功能，避免代码重复。
+"""
+
+import datetime
+from typing import Any, Dict, List, Optional
+
+
+class XMLRPCSerializer:
+    """XML-RPC序列化工具类
+    
+    统一处理XML-RPC序列化检查、转换和过滤逻辑，
+    避免在多个类中重复实现相同的序列化代码。
+    """
+    
+    # 敏感信息过滤模式
+    DEFAULT_EXCLUDE_PATTERNS = [
+        'password', 'secret', 'token', 'credential', 'auth', 'private'
+    ]
+    
+    @staticmethod
+    def is_serializable(value: Any) -> bool:
+        """检查值是否可以被XML-RPC序列化
+        
+        XML-RPC支持的类型：
+        - None (需要allow_none=True)
+        - bool, int, float, str, bytes
+        - datetime.datetime
+        - list (元素也必须可序列化)
+        - dict (键必须是字符串，值必须可序列化)
+        
+        Args:
+            value: 要检查的值
+            
+        Returns:
+            bool: 是否可序列化
+        """
+        # 基本类型
+        if value is None:
+            return True
+        if isinstance(value, (bool, int, float, str, bytes)):
+            return True
+        if isinstance(value, datetime.datetime):
+            return True
+        
+        # 严格检查：只允许内置的list和dict类型，不允许自定义类
+        value_type = type(value)
+        
+        # 检查是否为内置list类型（不是子类）
+        if value_type is list:
+            try:
+                for item in value:
+                    if not XMLRPCSerializer.is_serializable(item):
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        # 检查是否为内置tuple类型
+        if value_type is tuple:
+            try:
+                for item in value:
+                    if not XMLRPCSerializer.is_serializable(item):
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        # 检查是否为内置dict类型（不是子类，如DotAccessDict）
+        if value_type is dict:
+            try:
+                for k, v in value.items():
+                    # XML-RPC要求字典的键必须是字符串
+                    if not isinstance(k, str):
+                        return False
+                    if not XMLRPCSerializer.is_serializable(v):
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        # 其他类型都不可序列化
+        return False
+    
+    @staticmethod
+    def convert_to_serializable(value: Any) -> Optional[Any]:
+        """尝试将值转换为XML-RPC可序列化的格式
+        
+        Args:
+            value: 要转换的值
+            
+        Returns:
+            转换后的值，如果无法转换则返回None
+        """
+        # 如果已经可序列化，直接返回
+        if XMLRPCSerializer.is_serializable(value):
+            return value
+        
+        # 尝试转换类字典对象为标准字典
+        if hasattr(value, 'keys') and hasattr(value, 'items'):
+            try:
+                converted_dict = {}
+                for k, v in value.items():
+                    # 键必须是字符串
+                    if not isinstance(k, str):
+                        k = str(k)
+                    
+                    # 递归转换值
+                    converted_value = XMLRPCSerializer.convert_to_serializable(v)
+                    if converted_value is not None or v is None:
+                        converted_dict[k] = converted_value
+                    else:
+                        # 如果无法转换子值，跳过这个键值对
+                        print(f"跳过无法转换的字典项: {k} "
+                              f"(类型: {type(v).__name__})")
+                        continue
+                
+                return converted_dict
+            except Exception as e:
+                print(f"转换类字典对象失败: {e}")
+                return None
+        
+        # 尝试转换类列表对象为标准列表
+        if hasattr(value, '__iter__') and not isinstance(value, (str, bytes)):
+            try:
+                converted_list = []
+                for item in value:
+                    converted_item = XMLRPCSerializer.convert_to_serializable(item)
+                    if converted_item is not None or item is None:
+                        converted_list.append(converted_item)
+                    else:
+                        # 如果无法转换子项，跳过
+                        print(f"跳过无法转换的列表项: "
+                              f"(类型: {type(item).__name__})")
+                        continue
+                
+                return converted_list
+            except Exception as e:
+                print(f"转换类列表对象失败: {e}")
+                return None
+        
+        # 尝试转换为字符串表示
+        try:
+            str_value = str(value)
+            # 避免转换过长的字符串或包含敏感信息的对象
+            if (len(str_value) < 1000 and 
+                not any(pattern in str_value.lower() 
+                       for pattern in XMLRPCSerializer.DEFAULT_EXCLUDE_PATTERNS)):
+                return str_value
+        except Exception:
+            pass
+        
+        # 无法转换
+        return None
+    
+    @staticmethod
+    def filter_variables(variables: Dict[str, Any], 
+                        exclude_patterns: Optional[List[str]] = None) -> Dict[str, Any]:
+        """过滤变量字典，移除敏感变量和不可序列化的变量
+        
+        Args:
+            variables: 原始变量字典
+            exclude_patterns: 排除模式列表，如果为None则使用默认模式
+            
+        Returns:
+            Dict[str, Any]: 过滤后的变量字典
+        """
+        if exclude_patterns is None:
+            exclude_patterns = XMLRPCSerializer.DEFAULT_EXCLUDE_PATTERNS
+        
+        filtered_variables = {}
+        
+        for var_name, var_value in variables.items():
+            # 检查是否需要排除
+            should_exclude = False
+            var_name_lower = var_name.lower()
+            
+            # 检查变量名
+            for pattern in exclude_patterns:
+                if pattern.lower() in var_name_lower:
+                    should_exclude = True
+                    break
+            
+            # 如果值是字符串，也检查是否包含敏感信息
+            if not should_exclude and isinstance(var_value, str):
+                value_lower = var_value.lower()
+                for pattern in exclude_patterns:
+                    if (pattern.lower() in value_lower and 
+                        len(var_value) < 100):  # 只检查短字符串
+                        should_exclude = True
+                        break
+            
+            if not should_exclude:
+                # 尝试转换为可序列化的格式
+                serializable_value = XMLRPCSerializer.convert_to_serializable(var_value)
+                # 注意：None值转换后仍然是None，但这是有效的结果
+                if serializable_value is not None or var_value is None:
+                    filtered_variables[var_name] = serializable_value
+                else:
+                    print(f"跳过不可序列化的变量: {var_name} "
+                          f"(类型: {type(var_value).__name__})")
+            else:
+                print(f"跳过敏感变量: {var_name}")
+        
+        return filtered_variables
+    
+    @staticmethod
+    def validate_xmlrpc_data(data: Any) -> bool:
+        """验证数据是否可以通过XML-RPC传输
+        
+        Args:
+            data: 要验证的数据
+            
+        Returns:
+            bool: 是否可以传输
+        """
+        try:
+            import xmlrpc.client
+            # 尝试序列化数据
+            xmlrpc.client.dumps((data,), allow_none=True)
+            return True
+        except Exception:
+            return False
+
+
+# 创建全局序列化器实例，方便直接使用
+xmlrpc_serializer = XMLRPCSerializer() 

pytest_dsl/remote/__init__.py

@@ -4,7 +4,7 @@ Remote module for pytest-dsl.
 This module provides remote keyword server functionality.
 """
 
-__version__ = "0.15.4"
+__version__ = "0.15.5"
 
 # 导出远程关键字管理器和相关功能
 from .keyword_client import remote_keyword_manager, RemoteKeywordManager, RemoteKeywordClient

pytest_dsl/remote/keyword_client.py

@@ -59,7 +59,7 @@ class RemoteKeywordClient:
         try:
             param_names = self.server.get_keyword_arguments(name)
             doc = self.server.get_keyword_documentation(name)
-            
+
             # 尝试获取参数详细信息（包括默认值）
             param_details = []
             try:
@@ -87,7 +87,7 @@ class RemoteKeywordClient:
                 param_desc = param_detail.get('description',
                                               f'远程关键字参数: {param_name}')
                 param_default = param_detail.get('default')
-                
+
                 # 确保参数名称正确映射
                 parameters.append({
                     'name': param_name,
@@ -118,8 +118,10 @@ 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
@@ -131,7 +133,6 @@ class RemoteKeywordClient:
                 'doc': doc,
                 'param_details': param_details  # 缓存详细参数信息
             }
-
             # 保存参数映射
             self.param_mappings[name] = param_mapping
 
@@ -143,6 +144,9 @@ class RemoteKeywordClient:
         """执行远程关键字"""
         name = kwargs.pop('name')
 
+        # 在执行前同步最新的上下文变量
+        self._sync_context_variables_before_execution(kwargs.get('context'))
+
         # 移除context参数，因为它不能被序列化
         if 'context' in kwargs:
             kwargs.pop('context', None)
@@ -186,7 +190,6 @@ class RemoteKeywordClient:
         if name in self.keyword_cache:
             param_names = self.keyword_cache[name]['parameters']
             print(f"远程关键字 {name} 的参数列表: {param_names}")
-
             # 不再显示警告信息，因为参数已经在服务器端正确处理
             # 服务器端会使用默认值或者报错，客户端不需要重复警告
 
@@ -209,7 +212,8 @@ class RemoteKeywordClient:
                     print(f"远程关键字捕获的变量: {return_data['captures']}")
 
                 # 处理会话状态
-                if 'session_state' in return_data and return_data['session_state']:
+                if ('session_state' in return_data and
+                        return_data['session_state']):
                     print(f"远程关键字会话状态: {return_data['session_state']}")
 
                 # 处理响应数据
@@ -217,7 +221,8 @@ class RemoteKeywordClient:
                     print("远程关键字响应数据: 已接收")
 
                 # 检查是否为新的统一返回格式（包含captures等字段）
-                if ('captures' in return_data or 'session_state' in return_data or
+                if ('captures' in return_data or
+                        'session_state' in return_data or
                         'metadata' in return_data):
                     # 返回完整的新格式，让DSL执行器处理变量捕获
                     return return_data
@@ -233,6 +238,72 @@ class RemoteKeywordClient:
             traceback = '\n'.join(result.get('traceback', []))
             raise Exception(f"远程关键字执行失败: {error_msg}\n{traceback}")
 
+    def _sync_context_variables_before_execution(self, context):
+        """在执行远程关键字前同步最新的上下文变量
+
+        Args:
+            context: TestContext实例，如果为None则跳过同步
+        """
+        if context is None:
+            return
+
+        try:
+            # 获取所有上下文变量
+            context_variables = context.get_all_context_variables()
+
+            if not context_variables:
+                print("没有上下文变量需要同步")
+                return
+
+            # 使用统一的序列化工具进行变量过滤
+            from pytest_dsl.core.serialization_utils import XMLRPCSerializer
+            
+            # 扩展排除模式
+            exclude_patterns = self.sync_config.get('yaml_exclude_patterns', [
+                'password', 'secret', 'token', 'credential', 'auth',
+                'private', 'remote_servers'
+            ])
+            
+            variables_to_sync = XMLRPCSerializer.filter_variables(
+                context_variables, exclude_patterns)
+
+            if variables_to_sync:
+                # 调用远程服务器的变量同步接口
+                try:
+                    result = self.server.sync_variables_from_client(
+                        variables_to_sync, self.api_key)
+                    if result.get('status') == 'success':
+                        print(f"✅ 实时同步 {len(variables_to_sync)} 个上下文变量到远程服务器")
+                    else:
+                        print(f"❌ 实时同步变量失败: {result.get('error', '未知错误')}")
+                except Exception as e:
+                    print(f"❌ 调用远程变量同步接口失败: {str(e)}")
+            else:
+                print("没有需要实时同步的变量")
+
+        except Exception as e:
+            logger.warning(f"实时变量同步失败: {str(e)}")
+            print(f"❌ 实时变量同步失败: {str(e)}")
+
+    def _collect_context_variables(self, context):
+        """从TestContext收集所有变量（包括外部提供者变量）
+
+        Args:
+            context: TestContext实例
+
+        Returns:
+            dict: 包含所有上下文变量的字典
+        """
+        if context is None:
+            return {}
+
+        try:
+            # 使用新的get_all_context_variables方法
+            return context.get_all_context_variables()
+        except Exception as e:
+            logger.warning(f"收集上下文变量失败: {str(e)}")
+            return {}
+
     def _send_initial_variables(self):
         """连接时发送初始变量到远程服务器"""
         try:
@@ -247,17 +318,28 @@ class RemoteKeywordClient:
                 variables_to_send.update(self._collect_yaml_variables())
 
             if variables_to_send:
-                try:
-                    # 调用远程服务器的变量接收接口
-                    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"传递变量到远程服务器失败: "
-                              f"{result.get('error', '未知错误')}")
-                except Exception as e:
-                    print(f"调用远程变量接口失败: {str(e)}")
+                # 使用统一的序列化工具进行变量过滤和转换
+                from pytest_dsl.core.serialization_utils import (
+                    XMLRPCSerializer
+                )
+                serializable_variables = XMLRPCSerializer.filter_variables(
+                    variables_to_send)
+                
+                if serializable_variables:
+                    try:
+                        # 调用远程服务器的变量接收接口
+                        result = self.server.sync_variables_from_client(
+                            serializable_variables, self.api_key)
+                        if result.get('status') == 'success':
+                            print(f"成功传递 {len(serializable_variables)} "
+                                  f"个变量到远程服务器")
+                        else:
+                            print(f"传递变量到远程服务器失败: "
+                                  f"{result.get('error', '未知错误')}")
+                    except Exception as e:
+                        print(f"调用远程变量接口失败: {str(e)}")
+                else:
+                    print("没有可序列化的变量需要传递")
             else:
                 print("没有需要传递的变量")
 
@@ -286,9 +368,17 @@ class RemoteKeywordClient:
                     with open(storage_file, 'r', encoding='utf-8') as f:
                         stored_vars = json.load(f)
                         # 只同步g_开头的全局变量
-                        for name, value in stored_vars.items():
-                            if name.startswith('g_'):
-                                variables[name] = value
+                        global_vars = {
+                            name: value for name, value in stored_vars.items() 
+                            if name.startswith('g_')
+                        }
+                        if global_vars:
+                            from pytest_dsl.core.serialization_utils import (
+                                XMLRPCSerializer
+                            )
+                            filtered_global_vars = XMLRPCSerializer.filter_variables(
+                                global_vars)
+                            variables.update(filtered_global_vars)
         except Exception as e:
             logger.warning(f"收集全局变量失败: {str(e)}")
 
@@ -304,47 +394,41 @@ class RemoteKeywordClient:
             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', 'token', 'credential', 'auth',
-                    'private', 'remote_servers'  # 排除远程服务器配置避免循环
-                ])
+                exclude_patterns = self.sync_config.get(
+                    'yaml_exclude_patterns', [
+                        'password', 'secret', 'token', 'credential', 'auth',
+                        'private', 'remote_servers'  # 排除远程服务器配置避免循环
+                    ]
+                )
 
                 if sync_keys:
                     # 如果指定了特定键，只传递这些键，直接使用原始变量名
-                    for key in sync_keys:
-                        if key in yaml_data:
-                            variables[key] = yaml_data[key]
+                    specific_vars = {
+                        key: yaml_data[key] for key in sync_keys 
+                        if key in yaml_data
+                    }
+                    if specific_vars:
+                        from pytest_dsl.core.serialization_utils import (
+                            XMLRPCSerializer
+                        )
+                        filtered_specific_vars = XMLRPCSerializer.filter_variables(
+                            specific_vars)
+                        variables.update(filtered_specific_vars)
+                        for key in filtered_specific_vars:
                             print(f"传递指定YAML变量: {key}")
                 else:
                     # 传递所有YAML变量，但排除敏感信息
-                    for key, value in yaml_data.items():
-                        # 检查是否包含敏感信息
-                        key_lower = key.lower()
-                        should_exclude = False
-
-                        for pattern in exclude_patterns:
-                            if pattern.lower() in key_lower:
-                                should_exclude = True
-                                break
-
-                        # 如果值是字符串，也检查是否包含敏感信息
-                        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):  # 只检查短字符串
-                                    should_exclude = True
-                                    break
-
-                        if not should_exclude:
-                            # 直接使用原始变量名，不添加yaml_前缀，实现无缝传递
-                            variables[key] = value
-                            print(f"传递YAML变量: {key}")
-                        else:
-                            print(f"跳过敏感YAML变量: {key}")
+                    from pytest_dsl.core.serialization_utils import (
+                        XMLRPCSerializer
+                    )
+                    filtered_yaml_vars = XMLRPCSerializer.filter_variables(
+                        yaml_data, exclude_patterns)
+                    variables.update(filtered_yaml_vars)
+                    for key in filtered_yaml_vars:
+                        print(f"传递YAML变量: {key}")
 
         except Exception as e:
             logger.warning(f"收集YAML变量失败: {str(e)}")

pytest_dsl/remote/keyword_server.py

@@ -1,5 +1,4 @@
 import xmlrpc.server
-from functools import partial
 import inspect
 import json
 import sys
@@ -8,12 +7,10 @@ import signal
 import atexit
 import threading
 import time
-from typing import Dict, Any, Callable, List
 
 from pytest_dsl.core.keyword_manager import keyword_manager
 from pytest_dsl.remote.hook_manager import hook_manager, HookType
-# 导入变量桥接模块，确保hook被注册
-from pytest_dsl.remote import variable_bridge
+
 
 class RemoteKeywordServer:
     """远程关键字服务器，提供关键字的远程调用能力"""
@@ -35,7 +32,9 @@ class RemoteKeywordServer:
 
     def _register_builtin_keywords(self):
         """注册所有内置关键字，复用本地模式的加载逻辑"""
-        from pytest_dsl.core.plugin_discovery import load_all_plugins, scan_local_keywords
+        from pytest_dsl.core.plugin_discovery import (
+            load_all_plugins, scan_local_keywords
+        )
 
         # 0. 首先加载内置关键字模块（确保内置关键字被注册）
         print("正在加载内置关键字...")
@@ -63,7 +62,8 @@ class RemoteKeywordServer:
             print(f"接收到信号 {signum}，正在关闭服务器...")
 
             # 在新线程中执行关闭逻辑，避免阻塞信号处理器
-            shutdown_thread = threading.Thread(target=self._shutdown_in_thread, daemon=True)
+            shutdown_thread = threading.Thread(
+                target=self._shutdown_in_thread, daemon=True)
             shutdown_thread.start()
 
         # 保存信号处理器引用
@@ -119,7 +119,8 @@ class RemoteKeywordServer:
     def start(self):
         """启动远程关键字服务器"""
         try:
-            self.server = xmlrpc.server.SimpleXMLRPCServer((self.host, self.port), allow_none=True)
+            self.server = xmlrpc.server.SimpleXMLRPCServer(
+                (self.host, self.port), allow_none=True)
         except OSError as e:
             if "Address already in use" in str(e):
                 print(f"端口 {self.port} 已被占用，请使用其他端口或关闭占用该端口的进程")
@@ -207,7 +208,8 @@ class RemoteKeywordServer:
         try:
             # 确保参数是字典格式
             if not isinstance(args_dict, dict):
-                args_dict = json.loads(args_dict) if isinstance(args_dict, str) else {}
+                args_dict = json.loads(args_dict) if isinstance(
+                    args_dict, str) else {}
 
             # 获取关键字信息
             keyword_info = keyword_manager.get_keyword_info(name)
@@ -226,6 +228,15 @@ class RemoteKeywordServer:
             # 创建测试上下文（所有关键字都需要）
             from pytest_dsl.core.context import TestContext
             test_context = TestContext()
+
+            # 设置变量提供者，确保可以访问YAML变量和全局变量
+            try:
+                from pytest_dsl.core.variable_providers import setup_context_with_default_providers
+                setup_context_with_default_providers(test_context)
+            except ImportError:
+                # 如果导入失败，记录警告但继续执行
+                print("警告：无法设置变量提供者")
+
             exec_kwargs['context'] = test_context
 
             # 映射参数（通用逻辑）
@@ -292,10 +303,10 @@ class RemoteKeywordServer:
 
     def get_keyword_parameter_details(self, name):
         """获取关键字的参数详细信息，包括默认值
-        
+
         Args:
             name: 关键字名称
-            
+
         Returns:
             list: 参数详细信息列表，每个元素包含name, mapping, description, default
         """
@@ -311,7 +322,7 @@ class RemoteKeywordServer:
                 'description': param.description,
                 'default': param.default
             })
-        
+
         return param_details
 
     def get_keyword_documentation(self, name):
@@ -405,7 +416,7 @@ class RemoteKeywordServer:
 
             # 将所有同步的变量直接注入到yaml_vars中，实现无缝访问
             from pytest_dsl.core.yaml_vars import yaml_vars
-            
+
             for name, value in variables.items():
                 # 直接设置到yaml_vars中，确保所有关键字都能无缝访问
                 yaml_vars._variables[name] = value
@@ -419,7 +430,7 @@ class RemoteKeywordServer:
                     print(f"✓ 全局变量 {name} 已注入到global_context")
 
             print(f"✅ 总共同步了 {len(variables)} 个变量，全部实现无缝访问")
-            
+
             return {
                 'status': 'success',
                 'message': f'成功同步 {len(variables)} 个变量，全部实现无缝访问'
@@ -550,6 +561,7 @@ class RemoteKeywordServer:
                 'error': f'列出变量失败: {str(e)}'
             }
 
+
 def main():
     """启动远程关键字服务器的主函数"""
     import argparse
@@ -572,7 +584,8 @@ def main():
     _auto_load_extensions()
 
     # 创建并启动服务器（服务器初始化时会自动加载标准关键字）
-    server = RemoteKeywordServer(host=args.host, port=args.port, api_key=args.api_key)
+    server = RemoteKeywordServer(
+        host=args.host, port=args.port, api_key=args.api_key)
     server.start()
 
 
@@ -591,7 +604,8 @@ def _load_extensions(extensions_arg):
             if os.path.isfile(ext_path) and ext_path.endswith('.py'):
                 # 加载单个Python文件
                 module_name = os.path.splitext(os.path.basename(ext_path))[0]
-                spec = importlib.util.spec_from_file_location(module_name, ext_path)
+                spec = importlib.util.spec_from_file_location(
+                    module_name, ext_path)
                 module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(module)
                 print(f"已加载扩展模块: {ext_path}")
@@ -601,7 +615,8 @@ def _load_extensions(extensions_arg):
                     if filename.endswith('.py') and not filename.startswith('_'):
                         file_path = os.path.join(ext_path, filename)
                         module_name = os.path.splitext(filename)[0]
-                        spec = importlib.util.spec_from_file_location(module_name, file_path)
+                        spec = importlib.util.spec_from_file_location(
+                            module_name, file_path)
                         module = importlib.util.module_from_spec(spec)
                         spec.loader.exec_module(module)
                         print(f"已加载扩展模块: {file_path}")
@@ -631,5 +646,6 @@ def _auto_load_extensions():
         print(f"发现扩展文件: {remote_ext_file}")
         _load_extensions(remote_ext_file)
 
+
 if __name__ == '__main__':
     main()

{pytest_dsl-0.15.4.dist-info → pytest_dsl-0.15.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-dsl
-Version: 0.15.4
+Version: 0.15.5
 Summary: A DSL testing framework based on pytest
 Author: Chen Shuanglin
 License: MIT

{pytest_dsl-0.15.4.dist-info → pytest_dsl-0.15.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pytest_dsl/__init__.py,sha256=kh7TLykNy37PBjppBv0qSXcQ-fCbLTE3apemmC8HYL0,6813
+pytest_dsl/__init__.py,sha256=Mb4fBll66yNvWOpESky6GF-iHFrdroeS5yRwUOCAs0Q,6813
 pytest_dsl/cli.py,sha256=kuCEp0FOmlbes8CreAugSwYyU8yoU_oG3HzSGSFh2Cs,13246
 pytest_dsl/conftest_adapter.py,sha256=cevEb0oEZKTZfUrGe1-CmkFByxKhUtjuurBJP7kpLc0,149
 pytest_dsl/main_adapter.py,sha256=pUIPN_EzY3JCDlYK7yF_OeLDVqni8vtG15G7gVzPJXg,181
@@ -7,9 +7,9 @@ pytest_dsl/core/__init__.py,sha256=ersUoxIWSrisxs9GX_STlH4XAbjNxAWUQB0NboaC5zI,3
 pytest_dsl/core/auth_provider.py,sha256=IZfXXrr4Uuc8QHwRPvhHSzNa2fwrqhjYts1xh78D39Q,14861
 pytest_dsl/core/auto_decorator.py,sha256=9Mga-GB4AzV5nkB6zpfaq8IuHa0KOH8LlFvnWyH_tnU,6623
 pytest_dsl/core/auto_directory.py,sha256=egyTnVxtGs4P75EIivRauLRPJfN9aZpoGVvp_Ma72AM,2714
-pytest_dsl/core/context.py,sha256=9F3aXuKkePO94mTZh4VKYoOeu4U2HKXzlgui4HtEz8c,3044
+pytest_dsl/core/context.py,sha256=F6c8U2jSNNqiI_QUn6rn_6pcIi-H_M9bthH-gu92P-0,3985
 pytest_dsl/core/custom_keyword_manager.py,sha256=SSlsCv3GFMqmtORrqp2I70DvI5vjcBHUgofCgQATbtk,16272
-pytest_dsl/core/dsl_executor.py,sha256=M6xEBaQOsjaUiiiPG-k-owRU7V5lXs3EPrrDGfDQzo8,61054
+pytest_dsl/core/dsl_executor.py,sha256=r1lGlakj5PXWguUnQdEoDCaMr6_jYQTizFHEwZkiY5k,65223
 pytest_dsl/core/dsl_executor_utils.py,sha256=ZJLSYSsiKHqg53d3Bl--ZF8m9abd5kpqdevWl31KEZg,2276
 pytest_dsl/core/execution_tracker.py,sha256=Pwcxraxt_xkOouq32KBqola-OVfnbaomCoMTyUIqoN4,9476
 pytest_dsl/core/global_context.py,sha256=1wU0I1fd5I9K3rX90hu6BaodynnYRQNFBFhcecO5eQE,4629
@@ -27,6 +27,7 @@ pytest_dsl/core/parser.py,sha256=SvTQ4jgMSe3MITSu9PftraElPAzVaBbNPHMEk1H_lFY,165
 pytest_dsl/core/parsetab.py,sha256=o4XbFKwpsi3fYmfI_F6u5NSM61Qp6gTx-Sfh1jDINxI,31767
 pytest_dsl/core/plugin_discovery.py,sha256=3pt3EXJ7EPF0rkUlyDZMVHkIiTy2vicdIIQJkrHXZjY,8305
 pytest_dsl/core/remote_server_registry.py,sha256=MqAf2w0W_5D-zSClD87f9JDNQv-irZ4BrS03dcOFGU0,11046
+pytest_dsl/core/serialization_utils.py,sha256=b51uywA13vLU_G8rKFVl_BovN7A6mT-XYvn99OpqF54,8303
 pytest_dsl/core/utils.py,sha256=yAe-PtPTB7gSy8xa_V9UBk4L5SELvTEKiAhkiG4_2rM,5374
 pytest_dsl/core/validator.py,sha256=2mjw7yiDEMu80FjJ_y2KCS-vA1Tb4kotrKkmLwpRe8Y,17420
 pytest_dsl/core/variable_providers.py,sha256=ee81Pzy3GlU7q4taoSSd5E7YW87iPdusH0TfxV-0aUw,6198
@@ -69,15 +70,15 @@ pytest_dsl/keywords/assertion_keywords.py,sha256=obW06H_3AizsvEM_9VE2JVuwvgrNVqP
 pytest_dsl/keywords/global_keywords.py,sha256=4yw5yeXoGf_4W26F39EA2Pp-mH9GiKGy2jKgFO9a_wM,2509
 pytest_dsl/keywords/http_keywords.py,sha256=NMOLqD9m7iNLIYKnkQiinZilgLNopd2QzxRgmnliaNc,28976
 pytest_dsl/keywords/system_keywords.py,sha256=hjsACYER87rseSj4thBFnjDqe6At5hBT4Gjifj4ulDE,24470
-pytest_dsl/remote/__init__.py,sha256=NyCyZ7VCjh0kJbdheSScNz-aA5UIFAJJXvvFIvoYCio,1844
+pytest_dsl/remote/__init__.py,sha256=qNoYEZKl0m5GtDsl5YhLBOhw9Qn0x9lMrmX79ZZxOq8,1844
 pytest_dsl/remote/hook_manager.py,sha256=0hwRKP8yhcnfAnrrnZGVT-S0TBgo6c0A4qO5XRpvV1U,4899
-pytest_dsl/remote/keyword_client.py,sha256=BL80MOaLroUi0v-9sLtkJ55g1R0Iw9SE1k11Ifwqx-I,17292
-pytest_dsl/remote/keyword_server.py,sha256=vGIE3Bhh461xX_u1U-Cf5nrWL2GQFYdtQdcMWfFIYgE,22320
+pytest_dsl/remote/keyword_client.py,sha256=HjVfZxvn549bo9-QYobIubVa4Knch8y5EVvNuVVJEM8,20572
+pytest_dsl/remote/keyword_server.py,sha256=XSU8ojOhNV5WtvYNwn_HYiAulj7_L35IvtG7FECqGVo,22668
 pytest_dsl/remote/variable_bridge.py,sha256=dv-d3Gq9ttvvrXM1fdlLtoSOPB6vRp0_GBOwX4wvcy8,7121
 pytest_dsl/templates/keywords_report.html,sha256=7x84iq6hi08nf1iQ95jZ3izcAUPx6JFm0_8xS85CYws,31241
-pytest_dsl-0.15.4.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
-pytest_dsl-0.15.4.dist-info/METADATA,sha256=SFajau629WciJAm3w3txzx-KPxghyiCPTMpAVmSaYuM,29655
-pytest_dsl-0.15.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_dsl-0.15.4.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
-pytest_dsl-0.15.4.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
-pytest_dsl-0.15.4.dist-info/RECORD,,
+pytest_dsl-0.15.5.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
+pytest_dsl-0.15.5.dist-info/METADATA,sha256=I9tSZQifKuUGk0wE_avhfYNMCYaGdaNKikY4l6o_srA,29655
+pytest_dsl-0.15.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_dsl-0.15.5.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
+pytest_dsl-0.15.5.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
+pytest_dsl-0.15.5.dist-info/RECORD,,