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

pytest_dsl/core/variable_utils.py

@@ -1,50 +1,54 @@
+"""变量替换工具模块
+
+该模块提供了高级的变量替换功能，支持复杂的变量访问语法。
+"""
+
 import re
 import json
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List
 from pytest_dsl.core.global_context import global_context
 from pytest_dsl.core.context import TestContext
-from pytest_dsl.core.yaml_vars import yaml_vars
 
 
 class VariableReplacer:
-    """统一的变量替换工具类
-
-    提供统一的变量替换功能，支持字符串、字典和列表中的变量替换。
-    变量查找优先级：本地变量 > 测试上下文 > YAML变量 > 全局上下文
-    """
+    """变量替换器，支持高级变量访问语法"""
 
     def __init__(self, local_variables: Dict[str, Any] = None, test_context: TestContext = None):
         """初始化变量替换器
 
         Args:
             local_variables: 本地变量字典
-            test_context: 测试上下文对象
+            test_context: 测试上下文
         """
         self.local_variables = local_variables or {}
-        self._test_context = test_context or TestContext()
+        self._test_context = test_context
 
     @property
     def test_context(self) -> TestContext:
-        """获取测试上下文，确保始终使用最新的上下文对象
+        """获取测试上下文，如果没有提供则尝试从关键字管理器获取"""
+        if self._test_context:
+            return self._test_context
 
-        如果上下文对象中包含executor属性，则使用executor的上下文
-        （这确保即使上下文被替换也能获取正确的引用）
-
-        Returns:
-            测试上下文对象
-        """
-        if hasattr(self._test_context, 'executor') and self._test_context.executor is not None:
-            return self._test_context.executor.test_context
-        return self._test_context
+        # 尝试从关键字管理器获取当前上下文
+        try:
+            from pytest_dsl.core.keyword_manager import keyword_manager
+            return getattr(keyword_manager, 'current_context', None)
+        except ImportError:
+            return None
 
     def get_variable(self, var_name: str) -> Any:
-        """获取变量值，按照优先级查找
+        """获取变量值，按优先级顺序查找
+
+        查找顺序：
+        1. 本地变量
+        2. 测试上下文
+        3. 全局上下文（包含YAML变量的访问）
 
         Args:
             var_name: 变量名
 
         Returns:
-            变量值，如果变量不存在则抛出 KeyError
+            变量值
 
         Raises:
             KeyError: 当变量不存在时
@@ -54,17 +58,13 @@ class VariableReplacer:
             value = self.local_variables[var_name]
             return self._convert_value(value)
 
-        # 从测试上下文中获取
-        if self.test_context.has(var_name):
-            value = self.test_context.get(var_name)
+        # 从测试上下文中获取（优先级高于YAML变量）
+        context = self.test_context
+        if context and context.has(var_name):
+            value = context.get(var_name)
             return self._convert_value(value)
 
-        # 从YAML变量中获取
-        yaml_value = yaml_vars.get_variable(var_name)
-        if yaml_value is not None:
-            return self._convert_value(yaml_value)
-
-        # 从全局上下文获取
+        # 从全局上下文获取（包含对YAML变量的统一访问）
         if global_context.has_variable(var_name):
             value = global_context.get_variable(var_name)
             return self._convert_value(value)
@@ -130,7 +130,8 @@ class VariableReplacer:
             try:
                 var_value = self._parse_variable_path(var_ref)
                 # 替换变量引用
-                result = result[:match.start()] + str(var_value) + result[match.end():]
+                result = result[:match.start()] + str(var_value) + \
+                    result[match.end():]
             except (KeyError, IndexError, TypeError) as e:
                 raise KeyError(f"无法解析变量引用 '${{{var_ref}}}': {str(e)}")
 
@@ -170,7 +171,8 @@ class VariableReplacer:
 
         # 逐步访问路径
         for part in path_parts[1:]:
-            current_value = self._access_value(current_value, part, root_var_name)
+            current_value = self._access_value(
+                current_value, part, root_var_name)
 
         return current_value
 
@@ -258,14 +260,16 @@ class VariableReplacer:
                         raise KeyError(f"字典中不存在键 '{key}'")
                     return current_value[key]
                 else:
-                    raise TypeError(f"无法在 {type(current_value).__name__} 类型上使用字符串键访问")
+                    raise TypeError(
+                        f"无法在 {type(current_value).__name__} 类型上使用字符串键访问")
 
             # 处理数字索引
             try:
                 index = int(key_content)
                 if isinstance(current_value, (list, tuple)):
                     if index >= len(current_value) or index < -len(current_value):
-                        raise IndexError(f"数组索引 {index} 超出范围，数组长度为 {len(current_value)}")
+                        raise IndexError(
+                            f"数组索引 {index} 超出范围，数组长度为 {len(current_value)}")
                     return current_value[index]
                 elif isinstance(current_value, dict):
                     # 字典也可以用数字键
@@ -274,7 +278,8 @@ class VariableReplacer:
                         raise KeyError(f"字典中不存在键 '{index}' 或 '{str_key}'")
                     return current_value.get(index, current_value.get(str_key))
                 else:
-                    raise TypeError(f"无法在 {type(current_value).__name__} 类型上使用索引访问")
+                    raise TypeError(
+                        f"无法在 {type(current_value).__name__} 类型上使用索引访问")
             except ValueError:
                 raise ValueError(f"无效的索引格式: '{key_content}'")
 
@@ -283,7 +288,8 @@ class VariableReplacer:
             if isinstance(current_value, dict) and access_token in current_value:
                 return current_value[access_token]
             else:
-                raise KeyError(f"无法访问属性 '{access_token}'，当前值类型是 {type(current_value).__name__}")
+                raise KeyError(
+                    f"无法访问属性 '{access_token}'，当前值类型是 {type(current_value).__name__}")
 
     def replace_in_dict(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """递归替换字典中的变量引用
@@ -303,7 +309,8 @@ class VariableReplacer:
         result = {}
         for key, value in data.items():
             # 替换键中的变量
-            new_key = self.replace_in_string(key) if isinstance(key, str) else key
+            new_key = self.replace_in_string(
+                key) if isinstance(key, str) else key
             # 替换值中的变量
             new_value = self.replace_in_value(value)
             result[new_key] = new_value
@@ -409,4 +416,4 @@ class VariableReplacer:
             return yaml.dump(replaced_data, allow_unicode=True)
         except:
             # 如果YAML解析失败，直接作为字符串处理
-            return self.replace_in_string(yaml_str)
+            return self.replace_in_string(yaml_str)

pytest_dsl/core/yaml_loader.py

@@ -31,50 +31,91 @@ def add_yaml_options(parser):
 
 
 def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None,
-                                  project_root=None, environment=None):
-    """从参数加载YAML变量文件（通用函数）
+                                  project_root=None, environment=None,
+                                  auto_load_default=None):
+    """从命令行参数加载YAML变量
 
     Args:
         yaml_files: YAML文件列表
         yaml_vars_dir: YAML变量目录路径
-        project_root: 项目根目录（用于默认config目录）
+        project_root: 项目根目录
         environment: 环境名称（用于hook加载）
+        auto_load_default: 是否自动加载默认配置
+                          None - 根据用户输入智能判断
+                          True - 强制加载默认配置  
+                          False - 不加载默认配置
     """
-    # 首先尝试通过hook加载变量
+    # 智能判断是否应该加载默认配置
+    if auto_load_default is None:
+        # 如果用户指定了具体的YAML文件，不自动加载默认配置
+        # 如果用户指定了具体的目录，也不自动加载默认配置
+        user_specified_files = bool(yaml_files)
+        user_specified_dir = bool(yaml_vars_dir)
+        auto_load_default = not (user_specified_files or user_specified_dir)
+
+        if not auto_load_default:
+            print("🎯 检测到用户指定了配置，跳过默认配置自动加载")
+        else:
+            print("📁 未指定配置，将自动加载默认配置目录")
+
+    # 首先尝试通过hook加载变量（最高优先级）
     hook_variables = _load_variables_through_hooks(
         project_root=project_root, environment=environment)
 
     if hook_variables:
-        print(f"通过Hook加载了 {len(hook_variables)} 个变量")
+        print(f"🔌 通过Hook加载了 {len(hook_variables)} 个变量")
         # 将hook变量加载到yaml_vars中
         yaml_vars._variables.update(hook_variables)
 
-    # 加载单个YAML文件
+    # 加载用户指定的YAML文件（第二优先级）
     if yaml_files:
         yaml_vars.load_yaml_files(yaml_files)
-        print(f"已加载YAML变量文件: {', '.join(yaml_files)}")
-
-    # 加载目录中的YAML文件
-    if yaml_vars_dir is None and project_root:
-        # 默认使用项目根目录下的config目录
-        yaml_vars_dir = str(Path(project_root) / 'config')
-        print(f"使用默认YAML变量目录: {yaml_vars_dir}")
-
-    if yaml_vars_dir and Path(yaml_vars_dir).exists():
-        yaml_vars.load_from_directory(yaml_vars_dir)
-        print(f"已加载YAML变量目录: {yaml_vars_dir}")
-        loaded_files = yaml_vars.get_loaded_files()
-        if loaded_files:
-            # 过滤出当前目录的文件
-            if yaml_vars_dir:
+        print(f"📄 已加载用户指定的YAML文件: {', '.join(yaml_files)}")
+
+    # 加载用户指定的目录中的YAML文件（第三优先级）
+    if yaml_vars_dir:
+        if Path(yaml_vars_dir).exists():
+            yaml_vars.load_from_directory(yaml_vars_dir)
+            print(f"📂 已加载用户指定的YAML目录: {yaml_vars_dir}")
+            loaded_files = yaml_vars.get_loaded_files()
+            if loaded_files:
+                # 过滤出当前目录的文件
                 dir_files = [f for f in loaded_files if Path(
                     f).parent == Path(yaml_vars_dir)]
                 if dir_files:
-                    print(f"目录中加载的文件: {', '.join(dir_files)}")
-            else:
-                print(f"加载的文件: {', '.join(loaded_files)}")
-    elif yaml_vars_dir:
-        print(f"YAML变量目录不存在: {yaml_vars_dir}")
+                    print(f"   目录中加载的文件: {', '.join(dir_files)}")
+        else:
+            print(f"⚠️ 用户指定的YAML目录不存在: {yaml_vars_dir}")
+
+    # 自动加载默认配置（最低优先级，仅在用户未指定配置时）
+    if auto_load_default:
+        default_yaml_vars_dir = None
+        if project_root:
+            # 默认使用项目根目录下的config目录
+            default_yaml_vars_dir = str(Path(project_root) / 'config')
+            print(f"🏠 使用默认YAML变量目录: {default_yaml_vars_dir}")
+
+        if default_yaml_vars_dir and Path(default_yaml_vars_dir).exists():
+            yaml_vars.load_from_directory(default_yaml_vars_dir)
+            print(f"📁 已加载默认YAML变量目录: {default_yaml_vars_dir}")
+            loaded_files = yaml_vars.get_loaded_files()
+            if loaded_files:
+                # 过滤出默认目录的文件
+                dir_files = [f for f in loaded_files if Path(
+                    f).parent == Path(default_yaml_vars_dir)]
+                if dir_files:
+                    print(f"   默认目录中加载的文件: {', '.join(dir_files)}")
+        elif default_yaml_vars_dir:
+            print(f"📁 默认YAML变量目录不存在: {default_yaml_vars_dir}")
+
+    # 显示最终加载的变量汇总
+    all_loaded_files = yaml_vars.get_loaded_files()
+    if all_loaded_files:
+        print(f"✅ 变量加载完成，共加载 {len(all_loaded_files)} 个文件")
+        if len(yaml_vars._variables) > 0:
+            print(f"📊 总共加载了 {len(yaml_vars._variables)} 个变量")
+    else:
+        print("⚠️ 未加载任何YAML变量文件")
 
     # 加载完YAML变量后，自动连接远程服务器
     load_remote_servers_from_yaml()
@@ -203,37 +244,136 @@ def load_yaml_variables(config):
     )
 
 
-def load_remote_servers_from_yaml():
-    """从YAML变量中加载远程服务器配置"""
+def load_remote_servers_from_yaml(variable_source=None):
+    """从YAML变量中加载远程服务器配置
+
+    Args:
+        variable_source: 自定义变量源，如果不提供则使用全局上下文
+    """
     try:
         from pytest_dsl.remote.keyword_client import remote_keyword_manager
 
-        # 获取远程服务器配置
-        remote_servers = yaml_vars.get_variable('remote_servers')
-        if not remote_servers:
-            return
+        # 支持自定义变量源
+        if variable_source and callable(variable_source):
+            variables = variable_source()
+            remote_servers = variables.get(
+                'remote_servers') if isinstance(variables, dict) else None
+        else:
+            # 使用默认的全局上下文
+            from pytest_dsl.core.global_context import global_context
+            remote_servers = global_context.get_variable('remote_servers')
 
-        print(f"发现 {len(remote_servers)} 个远程服务器配置")
+        if not remote_servers:
+            return []
+
+        # 支持两种格式：数组和字典
+        server_configs = []
+
+        if isinstance(remote_servers, list):
+            # 数组格式: [{'url': '...', 'alias': '...'}, ...]
+            server_configs = remote_servers
+            print(f"发现 {len(remote_servers)} 个远程服务器配置（数组格式）")
+        elif isinstance(remote_servers, dict):
+            # 字典格式: {'server1': {'url': '...', 'alias': '...'}, ...}
+            for server_name, server_config in remote_servers.items():
+                if isinstance(server_config, dict):
+                    # 如果没有指定alias，使用键名作为alias
+                    if 'alias' not in server_config:
+                        server_config = server_config.copy()
+                        server_config['alias'] = server_name
+                    server_configs.append(server_config)
+            print(f"发现 {len(server_configs)} 个远程服务器配置（字典格式）")
+        else:
+            print(
+                f"警告：remote_servers配置格式不支持，期望数组或字典，得到 {type(remote_servers)}")
+            return []
+
+        results = []
 
         # 注册远程服务器
-        for server_config in remote_servers:
+        for server_config in server_configs:
             if isinstance(server_config, dict):
                 url = server_config.get('url')
                 alias = server_config.get('alias')
                 api_key = server_config.get('api_key')
+                sync_config = server_config.get('sync_config')
 
                 if url and alias:
                     print(f"自动连接远程服务器: {alias} -> {url}")
                     success = remote_keyword_manager.register_remote_server(
-                        url, alias, api_key=api_key
+                        url, alias, api_key=api_key, sync_config=sync_config
                     )
                     if success:
                         print(f"✓ 远程服务器 {alias} 连接成功")
                     else:
                         print(f"✗ 远程服务器 {alias} 连接失败")
 
+                    results.append(
+                        {'alias': alias, 'url': url, 'success': success})
+                else:
+                    print(f"警告：服务器配置缺少必要字段 url 或 alias: {server_config}")
+
+        return results
+
     except ImportError:
         # 如果远程功能不可用，跳过
-        pass
+        return []
     except Exception as e:
         print(f"自动连接远程服务器时出现警告: {e}")
+        return []
+
+
+def register_remote_servers_from_config(servers_config, variable_providers=None):
+    """从配置注册远程服务器的独立函数
+
+    这个函数可以被其他系统独立调用，不依赖YAML配置。
+
+    Args:
+        servers_config: 服务器配置列表或单个配置
+        variable_providers: 变量提供者列表，用于同步自定义变量
+
+    Returns:
+        dict: 注册结果
+
+    Examples:
+        >>> # 单个服务器
+        >>> config = {'url': 'http://server:8270', 'alias': 'test'}
+        >>> result = register_remote_servers_from_config(config)
+
+        >>> # 多个服务器
+        >>> configs = [
+        ...     {'url': 'http://server1:8270', 'alias': 'server1'},
+        ...     {'url': 'http://server2:8270', 'alias': 'server2'}
+        ... ]
+        >>> results = register_remote_servers_from_config(configs)
+
+        >>> # 带变量提供者
+        >>> def my_vars():
+        ...     return {'env': 'prod', 'api_key': 'secret'}
+        >>> results = register_remote_servers_from_config(configs, [my_vars])
+    """
+    try:
+        from pytest_dsl.core.remote_server_registry import remote_server_registry
+
+        # 如果有变量提供者，先添加它们
+        if variable_providers:
+            remote_server_registry.clear_variable_providers()
+            for provider in variable_providers:
+                if callable(provider):
+                    remote_server_registry.add_variable_provider(provider)
+
+        # 确保servers_config是列表
+        if isinstance(servers_config, dict):
+            servers_config = [servers_config]
+        elif not isinstance(servers_config, list):
+            raise ValueError("servers_config必须是字典或字典列表")
+
+        # 使用注册器批量注册
+        return remote_server_registry.register_servers_from_config(servers_config)
+
+    except ImportError:
+        print("远程功能不可用，请检查依赖安装")
+        return {}
+    except Exception as e:
+        print(f"注册远程服务器时发生错误: {e}")
+        return {}

pytest_dsl/keywords/http_keywords.py

@@ -14,7 +14,6 @@ from typing import Dict, Any, Union
 
 from pytest_dsl.core.keyword_manager import keyword_manager
 from pytest_dsl.core.http_request import HTTPRequest
-from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.context import TestContext
 
 # 配置日志
@@ -293,8 +292,8 @@ def http_request(context, **kwargs):
     # 添加调试信息，检查客户端配置是否可用
     print(f"🌐 HTTP请求 - 客户端: {client_name}")
 
-    # 检查YAML变量中的http_clients配置（现在包含同步的变量）
-    http_clients_config = yaml_vars.get_variable("http_clients")
+    # 从context获取http_clients配置（统一的变量获取方式）
+    http_clients_config = context.get("http_clients")
     if http_clients_config:
         print(f"✓ 找到http_clients配置，包含 {len(http_clients_config)} 个客户端")
         if client_name in http_clients_config:
@@ -310,10 +309,15 @@ def http_request(context, **kwargs):
 
     with allure.step(f"发送HTTP请求 (客户端: {client_name}"
                      f"{', 会话: ' + session_name if session_name else ''})"):
+
+        # 确保http_client_manager有正确的context引用
+        from pytest_dsl.core.http_client import http_client_manager
+        http_client_manager.set_context(context)
+
         # 处理模板
         if template_name:
-            # 从YAML变量中获取模板
-            http_templates = yaml_vars.get_variable("http_templates") or {}
+            # 从context获取模板配置（统一的变量获取方式）
+            http_templates = context.get("http_templates") or {}
             template = http_templates.get(template_name)
 
             if not template:

pytest_dsl/remote/__init__.py

@@ -4,4 +4,66 @@ Remote module for pytest-dsl.
 This module provides remote keyword server functionality.
 """
 
-__version__ = "0.9.0" 
+__version__ = "0.15.4"
+
+# 导出远程关键字管理器和相关功能
+from .keyword_client import remote_keyword_manager, RemoteKeywordManager, RemoteKeywordClient
+from .keyword_server import RemoteKeywordServer
+from .variable_bridge import VariableBridge
+
+# 导出便捷函数
+
+
+def register_remote_server(url, alias, api_key=None, sync_config=None):
+    """注册远程关键字服务器的便捷函数
+
+    Args:
+        url: 服务器URL
+        alias: 服务器别名  
+        api_key: API密钥(可选)
+        sync_config: 变量同步配置(可选)
+
+    Returns:
+        bool: 是否成功连接
+    """
+    return remote_keyword_manager.register_remote_server(url, alias, api_key, sync_config)
+
+
+def register_multiple_servers(servers_config):
+    """批量注册远程服务器
+
+    Args:
+        servers_config: 服务器配置列表，每个配置包含url、alias等信息
+
+    Returns:
+        dict: 注册结果，键为alias，值为是否成功
+    """
+    results = {}
+    for server_config in servers_config:
+        if isinstance(server_config, dict):
+            url = server_config.get('url')
+            alias = server_config.get('alias')
+            api_key = server_config.get('api_key')
+            sync_config = server_config.get('sync_config')
+
+            if url and alias:
+                success = register_remote_server(
+                    url, alias, api_key, sync_config)
+                results[alias] = success
+
+    return results
+
+
+# 导出所有公共接口
+__all__ = [
+    # 核心类
+    'remote_keyword_manager',
+    'RemoteKeywordManager',
+    'RemoteKeywordClient',
+    'RemoteKeywordServer',
+    'VariableBridge',
+
+    # 便捷函数
+    'register_remote_server',
+    'register_multiple_servers',
+]

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

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

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

@@ -1,5 +1,5 @@
-pytest_dsl/__init__.py,sha256=QAn8612I9Fn7SnnuaU34ZiAImZ2sHnuVaLuHi3S_3p4,5254
-pytest_dsl/cli.py,sha256=bH2z5-Onqpir1ymB-DB-tu-fuI1nWHcwVo_3ve9Hgco,12845
+pytest_dsl/__init__.py,sha256=kh7TLykNy37PBjppBv0qSXcQ-fCbLTE3apemmC8HYL0,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
 pytest_dsl/plugin.py,sha256=CEwi-ci2rMevaAl9PwBw2WKXWRbXuHI1IkkDV0I0VIo,2224
@@ -7,29 +7,31 @@ 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=fXpVQon666Lz_PCexjkWMBBr-Xcd1SkDMp2vHar6eIs,664
-pytest_dsl/core/custom_keyword_manager.py,sha256=F9aSbth4x4-5nHb0N5uG04CpgwGnQv4RDGeRKR2WuIk,16001
-pytest_dsl/core/dsl_executor.py,sha256=G3Ad97REt1jWwRvp7LS2Nq7zy3S2ZtYKlJeAJANDstI,60200
+pytest_dsl/core/context.py,sha256=9F3aXuKkePO94mTZh4VKYoOeu4U2HKXzlgui4HtEz8c,3044
+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_utils.py,sha256=ZJLSYSsiKHqg53d3Bl--ZF8m9abd5kpqdevWl31KEZg,2276
 pytest_dsl/core/execution_tracker.py,sha256=Pwcxraxt_xkOouq32KBqola-OVfnbaomCoMTyUIqoN4,9476
-pytest_dsl/core/global_context.py,sha256=NcEcS2V61MT70tgAsGsFWQq0P3mKjtHQr1rgT3yTcyY,3535
+pytest_dsl/core/global_context.py,sha256=1wU0I1fd5I9K3rX90hu6BaodynnYRQNFBFhcecO5eQE,4629
 pytest_dsl/core/hook_manager.py,sha256=rqpcj9tBcxwFpoU2ZAfOWO8P0oyq02Ie_XUjq-9vFc0,2445
 pytest_dsl/core/hookable_executor.py,sha256=sxkyWF7bSkKzgVoNwUTvtDGOSgFKXXQHR5uYIf-9MaM,3969
 pytest_dsl/core/hookable_keyword_manager.py,sha256=e_guTVF1tU3pu_uzAUd4xNudFlYth42Ll2ESeRLlpjE,3833
 pytest_dsl/core/hookspecs.py,sha256=fBmvs8uIV9_M_FUQBgvHSDn51Z6ABXo9k0okf80wzeo,5071
-pytest_dsl/core/http_client.py,sha256=hdx8gI4JCmq1-96pbiKeyKzSQUzPAi08cRNmljiPQmY,15536
+pytest_dsl/core/http_client.py,sha256=h4RMCkfMYlKx2kdF53mcCJ-udux9q7LxsIeSXwXZt6o,16263
 pytest_dsl/core/http_request.py,sha256=6e-gTztH3wu2eSW27Nc0uPmyWjB6oBwndx8Vqnu5uyg,60030
 pytest_dsl/core/keyword_loader.py,sha256=3GQ4w5Zf2XdkoJ85uYXh9YB93_8L8OAb7vvuKE3-gVA,13864
 pytest_dsl/core/keyword_manager.py,sha256=5WZWwlYk74kGHh1T6WjCuVd8eelq2-UEXvDIe4U7rEI,7730
-pytest_dsl/core/keyword_utils.py,sha256=1zIKzbA8Lhifc97skzN4oJV-2Cljzf9aVSutwjU7LaA,19847
+pytest_dsl/core/keyword_utils.py,sha256=ONZxQJ0W7_knLGJpRdZvZ1srHLFybMuUZKI1wxoeaJA,20195
 pytest_dsl/core/lexer.py,sha256=o_EJIadfhgyCImI73Y9ybqlBE9AisgA6nOhxpXNlaMw,4648
 pytest_dsl/core/parser.py,sha256=SvTQ4jgMSe3MITSu9PftraElPAzVaBbNPHMEk1H_lFY,16597
 pytest_dsl/core/parsetab.py,sha256=o4XbFKwpsi3fYmfI_F6u5NSM61Qp6gTx-Sfh1jDINxI,31767
 pytest_dsl/core/plugin_discovery.py,sha256=3pt3EXJ7EPF0rkUlyDZMVHkIiTy2vicdIIQJkrHXZjY,8305
-pytest_dsl/core/utils.py,sha256=q0AMdw5HO33JvlA3UJeQ7IXh1Z_8K1QlwiM1_yiITrU,5350
+pytest_dsl/core/remote_server_registry.py,sha256=MqAf2w0W_5D-zSClD87f9JDNQv-irZ4BrS03dcOFGU0,11046
+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_utils.py,sha256=sx5DFZAO_syi0E_0ACisiZUQL9yxGeOfNmMtV6w9V3E,13947
-pytest_dsl/core/yaml_loader.py,sha256=PC-R05bmHDI1QyBhhnt2jEK2c50Sg2xKsMDDY7p5rRg,8165
+pytest_dsl/core/variable_providers.py,sha256=ee81Pzy3GlU7q4taoSSd5E7YW87iPdusH0TfxV-0aUw,6198
+pytest_dsl/core/variable_utils.py,sha256=5vB_0fnVaYyZ6rv23tv7kAyp_4xM8F3FIjxYrx3xen0,13927
+pytest_dsl/core/yaml_loader.py,sha256=Lvut8-RKaVC4Gfv09XTVoagX1W1JKXgiJFMv8P8R9o0,14372
 pytest_dsl/core/yaml_vars.py,sha256=PqbCGT_TmOXH09Pmm72sYtMEvV-sp9ocLqkuAUQYhhc,5047
 pytest_dsl/docs/custom_keywords.md,sha256=03dA_GeHxoLixA8Sqch14bhTbxXQCSfz9Kvged2fMCo,4381
 pytest_dsl/examples/__init__.py,sha256=FKkyLFOjxfC6XnJlW7iK_BUIX9dTIpXgoYN1pfs91ss,84
@@ -65,17 +67,17 @@ pytest_dsl/examples/quickstart/loops.auto,sha256=ZNZ6qP636v8QMY8QRyTUBB43gWCsqHb
 pytest_dsl/keywords/__init__.py,sha256=5aiyPU_t1UiB2MEZ6M9ffOKnV1mFT_2YHxnZvyWaBNI,372
 pytest_dsl/keywords/assertion_keywords.py,sha256=obW06H_3AizsvEM_9VE2JVuwvgrNVqP1kUTDd3U1SMk,23240
 pytest_dsl/keywords/global_keywords.py,sha256=4yw5yeXoGf_4W26F39EA2Pp-mH9GiKGy2jKgFO9a_wM,2509
-pytest_dsl/keywords/http_keywords.py,sha256=baT_p04lOqZpfmOvBdPdzW2_KTikMEJmKPvpEx5sddU,28839
+pytest_dsl/keywords/http_keywords.py,sha256=NMOLqD9m7iNLIYKnkQiinZilgLNopd2QzxRgmnliaNc,28976
 pytest_dsl/keywords/system_keywords.py,sha256=hjsACYER87rseSj4thBFnjDqe6At5hBT4Gjifj4ulDE,24470
-pytest_dsl/remote/__init__.py,sha256=syRSxTlTUfdAPleJnVS4MykRyEN8_SKiqlsn6SlIK8k,120
+pytest_dsl/remote/__init__.py,sha256=NyCyZ7VCjh0kJbdheSScNz-aA5UIFAJJXvvFIvoYCio,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/variable_bridge.py,sha256=dv-d3Gq9ttvvrXM1fdlLtoSOPB6vRp0_GBOwX4wvcy8,7121
 pytest_dsl/templates/keywords_report.html,sha256=7x84iq6hi08nf1iQ95jZ3izcAUPx6JFm0_8xS85CYws,31241
-pytest_dsl-0.15.3.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
-pytest_dsl-0.15.3.dist-info/METADATA,sha256=579CxhlZ843PKOTXZX93BkD_m85h36LCIthwXShHgcw,29655
-pytest_dsl-0.15.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_dsl-0.15.3.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
-pytest_dsl-0.15.3.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
-pytest_dsl-0.15.3.dist-info/RECORD,,
+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,,