pytest-dsl 0.15.4__tar.gz → 0.15.5__tar.gz

{pytest_dsl-0.15.4/pytest_dsl.egg-info → pytest_dsl-0.15.5}/PKG-INFO

@@ -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 → pytest_dsl-0.15.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytest-dsl"
-version = "0.15.4"
+version = "0.15.5"
 description = "A DSL testing framework based on pytest"
 readme = "README.md"
 requires-python = ">=3.9"

{pytest_dsl-0.15.4 → pytest_dsl-0.15.5}/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-0.15.4 → pytest_dsl-0.15.5}/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-0.15.4 → pytest_dsl-0.15.5}/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-0.15.5/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-0.15.4 → pytest_dsl-0.15.5}/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