redis-benchmarks-specification 0.1.280__py3-none-any.whl → 0.1.282__py3-none-any.whl

redis_benchmarks_specification/__runner__/runner.py

@@ -79,7 +79,9 @@ def run_local_command_with_timeout(command_str, timeout_seconds, description="co
         tuple: (success, stdout, stderr)
     """
     try:
-        logging.info(f"Running {description} with {timeout_seconds}s timeout: {command_str}")
+        logging.info(
+            f"Running {description} with {timeout_seconds}s timeout: {command_str}"
+        )
 
         # Use shell=True to support complex command strings with pipes, etc.
         process = subprocess.Popen(
@@ -87,7 +89,7 @@ def run_local_command_with_timeout(command_str, timeout_seconds, description="co
             shell=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            text=True
+            text=True,
         )
 
         try:
@@ -106,7 +108,9 @@ def run_local_command_with_timeout(command_str, timeout_seconds, description="co
             logging.error(f"{description} timed out after {timeout_seconds} seconds")
             process.kill()
             try:
-                stdout, stderr = process.communicate(timeout=5)  # Give 5 seconds to cleanup
+                stdout, stderr = process.communicate(
+                    timeout=5
+                )  # Give 5 seconds to cleanup
             except subprocess.TimeoutExpired:
                 stdout, stderr = "", "Process killed due to timeout"
             return False, stdout, f"Timeout after {timeout_seconds} seconds. {stderr}"
@@ -136,7 +140,9 @@ def calculate_process_timeout(command_str, buffer_timeout):
         if test_time_match:
             test_time = int(test_time_match.group(1))
             timeout = test_time + buffer_timeout
-            logging.info(f"Set process timeout to {timeout}s (test-time: {test_time}s + {buffer_timeout}s buffer)")
+            logging.info(
+                f"Set process timeout to {timeout}s (test-time: {test_time}s + {buffer_timeout}s buffer)"
+            )
             return timeout
 
     logging.info(f"Using default process timeout: {default_timeout}s")
@@ -170,7 +176,9 @@ def parse_size(size):
     return int(number * units[unit])
 
 
-def extract_expected_benchmark_duration(benchmark_command_str, override_memtier_test_time):
+def extract_expected_benchmark_duration(
+    benchmark_command_str, override_memtier_test_time
+):
     """
     Extract expected benchmark duration from command string or override.
 
@@ -242,7 +250,9 @@ def run_multiple_clients(
             if "memtier_benchmark" in client_tool:
                 # Set benchmark path based on local install option
                 if args.benchmark_local_install:
-                    full_benchmark_path = getattr(args, 'memtier_bin_path', 'memtier_benchmark')
+                    full_benchmark_path = getattr(
+                        args, "memtier_bin_path", "memtier_benchmark"
+                    )
                 else:
                     full_benchmark_path = f"/usr/local/bin/{client_tool}"
 
@@ -334,7 +344,9 @@ def run_multiple_clients(
             # Calculate container timeout
             container_timeout = 300  # 5 minutes default
             # Use new timeout_buffer argument, fallback to container_timeout_buffer for backward compatibility
-            buffer_timeout = getattr(args, 'timeout_buffer', getattr(args, 'container_timeout_buffer', 60))
+            buffer_timeout = getattr(
+                args, "timeout_buffer", getattr(args, "container_timeout_buffer", 60)
+            )
             if "test-time" in benchmark_command_str:
                 # Try to extract test time and add buffer
                 import re
@@ -520,17 +532,29 @@ def run_multiple_clients(
                         )
                     elif "vector-db-benchmark" in tool:
                         # For vector-db-benchmark, look for summary JSON file
-                        summary_files = [f for f in os.listdir(temporary_dir_client) if f.endswith("-summary.json")]
+                        summary_files = [
+                            f
+                            for f in os.listdir(temporary_dir_client)
+                            if f.endswith("-summary.json")
+                        ]
                         if summary_files:
-                            summary_filepath = os.path.join(temporary_dir_client, summary_files[0])
+                            summary_filepath = os.path.join(
+                                temporary_dir_client, summary_files[0]
+                            )
                             try:
-                                with open(summary_filepath, 'r') as f:
+                                with open(summary_filepath, "r") as f:
                                     vector_json = json.load(f)
-                                logging.info(f"Successfully read vector-db-benchmark JSON output from {summary_files[0]}")
+                                logging.info(
+                                    f"Successfully read vector-db-benchmark JSON output from {summary_files[0]}"
+                                )
                             except Exception as e:
-                                logging.warning(f"Failed to read vector-db-benchmark JSON from {summary_files[0]}: {e}")
+                                logging.warning(
+                                    f"Failed to read vector-db-benchmark JSON from {summary_files[0]}: {e}"
+                                )
                         else:
-                            logging.warning(f"No vector-db-benchmark summary JSON file found for client {client_index}")
+                            logging.warning(
+                                f"No vector-db-benchmark summary JSON file found for client {client_index}"
+                            )
 
                     logging.info(
                         f"Successfully read JSON output from client {client_index} ({tool})"
@@ -554,25 +578,33 @@ def run_multiple_clients(
             aggregated_json.update(pubsub_json)
             aggregated_json.update(vector_json)
             aggregated_stdout = json.dumps(aggregated_json, indent=2)
-            logging.info("Using merged JSON results from memtier, pubsub-sub-bench, and vector-db-benchmark clients")
+            logging.info(
+                "Using merged JSON results from memtier, pubsub-sub-bench, and vector-db-benchmark clients"
+            )
         elif memtier_json and pubsub_json:
             # Use memtier as base and add pubsub metrics
             aggregated_json = memtier_json.copy()
             aggregated_json.update(pubsub_json)
             aggregated_stdout = json.dumps(aggregated_json, indent=2)
-            logging.info("Using merged JSON results from memtier and pubsub-sub-bench clients")
+            logging.info(
+                "Using merged JSON results from memtier and pubsub-sub-bench clients"
+            )
         elif memtier_json and vector_json:
             # Use memtier as base and add vector metrics
             aggregated_json = memtier_json.copy()
             aggregated_json.update(vector_json)
             aggregated_stdout = json.dumps(aggregated_json, indent=2)
-            logging.info("Using merged JSON results from memtier and vector-db-benchmark clients")
+            logging.info(
+                "Using merged JSON results from memtier and vector-db-benchmark clients"
+            )
         elif pubsub_json and vector_json:
             # Use pubsub as base and add vector metrics
             aggregated_json = pubsub_json.copy()
             aggregated_json.update(vector_json)
             aggregated_stdout = json.dumps(aggregated_json, indent=2)
-            logging.info("Using merged JSON results from pubsub-sub-bench and vector-db-benchmark clients")
+            logging.info(
+                "Using merged JSON results from pubsub-sub-bench and vector-db-benchmark clients"
+            )
         elif memtier_json:
             # Only memtier available
             aggregated_json = memtier_json
@@ -591,7 +623,9 @@ def run_multiple_clients(
         else:
             # Fall back to concatenated stdout
             aggregated_stdout = "\n".join([r["stdout"] for r in successful_results])
-            logging.warning("No JSON results found, falling back to concatenated stdout")
+            logging.warning(
+                "No JSON results found, falling back to concatenated stdout"
+            )
 
     return aggregated_stdout, results
 
@@ -913,7 +947,9 @@ def prepare_vector_db_benchmark_parameters(
 
     # Add custom arguments if specified
     if "arguments" in clientconfig:
-        benchmark_command_str = " ".join(benchmark_command) + " " + clientconfig["arguments"]
+        benchmark_command_str = (
+            " ".join(benchmark_command) + " " + clientconfig["arguments"]
+        )
     else:
         benchmark_command_str = " ".join(benchmark_command)
 
@@ -1156,8 +1192,8 @@ def process_self_contained_coordinator_stream(
 
                     # Check if all tested commands are supported by this Redis instance
                     supported_commands = get_supported_redis_commands(redis_conns)
-                    commands_supported, unsupported_commands = check_test_command_support(
-                        benchmark_config, supported_commands
+                    commands_supported, unsupported_commands = (
+                        check_test_command_support(benchmark_config, supported_commands)
                     )
 
                     if not commands_supported:
@@ -1328,7 +1364,11 @@ def process_self_contained_coordinator_stream(
                     if "dbconfig" in benchmark_config:
                         if "preload_tool" in benchmark_config["dbconfig"]:
                             # Get timeout buffer for preload
-                            buffer_timeout = getattr(args, 'timeout_buffer', getattr(args, 'container_timeout_buffer', 60))
+                            buffer_timeout = getattr(
+                                args,
+                                "timeout_buffer",
+                                getattr(args, "container_timeout_buffer", 60),
+                            )
 
                             res = data_prepopulation_step(
                                 benchmark_config,
@@ -1397,8 +1437,13 @@ def process_self_contained_coordinator_stream(
                         benchmark_tool = "redis-benchmark"
 
                     # Set benchmark path based on local install option
-                    if args.benchmark_local_install and "memtier_benchmark" in benchmark_tool:
-                        full_benchmark_path = getattr(args, 'memtier_bin_path', 'memtier_benchmark')
+                    if (
+                        args.benchmark_local_install
+                        and "memtier_benchmark" in benchmark_tool
+                    ):
+                        full_benchmark_path = getattr(
+                            args, "memtier_bin_path", "memtier_benchmark"
+                        )
                     else:
                         full_benchmark_path = f"/usr/local/bin/{benchmark_tool}"
 
@@ -1564,7 +1609,7 @@ def process_self_contained_coordinator_stream(
                                 args.remote_profile_port,
                                 args.remote_profile_output_dir,
                                 args.remote_profile_username,
-                                args.remote_profile_password
+                                args.remote_profile_password,
                             )
 
                             # Extract expected benchmark duration
@@ -1576,13 +1621,17 @@ def process_self_contained_coordinator_stream(
                             profiling_started = remote_profiler.start_profiling(
                                 redis_conns[0] if redis_conns else None,
                                 test_name,
-                                expected_duration
+                                expected_duration,
                             )
 
                             if profiling_started:
-                                logging.info(f"Started remote profiling for test: {test_name}")
+                                logging.info(
+                                    f"Started remote profiling for test: {test_name}"
+                                )
                             else:
-                                logging.warning(f"Failed to start remote profiling for test: {test_name}")
+                                logging.warning(
+                                    f"Failed to start remote profiling for test: {test_name}"
+                                )
                                 remote_profiler = None
 
                         except Exception as e:
@@ -1634,14 +1683,22 @@ def process_self_contained_coordinator_stream(
                             )
 
                             # Calculate timeout for local process
-                            buffer_timeout = getattr(args, 'timeout_buffer', getattr(args, 'container_timeout_buffer', 60))
-                            process_timeout = calculate_process_timeout(benchmark_command_str, buffer_timeout)
+                            buffer_timeout = getattr(
+                                args,
+                                "timeout_buffer",
+                                getattr(args, "container_timeout_buffer", 60),
+                            )
+                            process_timeout = calculate_process_timeout(
+                                benchmark_command_str, buffer_timeout
+                            )
 
                             # Run with timeout
-                            success, client_container_stdout, stderr = run_local_command_with_timeout(
-                                benchmark_command_str,
-                                process_timeout,
-                                "memtier benchmark"
+                            success, client_container_stdout, stderr = (
+                                run_local_command_with_timeout(
+                                    benchmark_command_str,
+                                    process_timeout,
+                                    "memtier benchmark",
+                                )
                             )
 
                             if not success:
@@ -1666,7 +1723,9 @@ def process_self_contained_coordinator_stream(
                             # Set working directory based on tool
                             working_dir = benchmark_tool_workdir
                             if "vector-db-benchmark" in benchmark_tool:
-                                working_dir = "/app"  # vector-db-benchmark needs to run from /app
+                                working_dir = (
+                                    "/app"  # vector-db-benchmark needs to run from /app
+                                )
 
                             # Prepare volumes
                             volumes = {
@@ -1697,7 +1756,9 @@ def process_self_contained_coordinator_stream(
 
                             # Only add user for non-vector-db-benchmark tools to avoid permission issues
                             if "vector-db-benchmark" not in benchmark_tool:
-                                container_kwargs["user"] = f"{os.getuid()}:{os.getgid()}"
+                                container_kwargs["user"] = (
+                                    f"{os.getuid()}:{os.getgid()}"
+                                )
 
                             # Add environment variables for vector-db-benchmark
                             if "vector-db-benchmark" in benchmark_tool:
@@ -1761,13 +1822,19 @@ def process_self_contained_coordinator_stream(
                     if remote_profiler is not None:
                         try:
                             logging.info("Waiting for remote profiling to complete...")
-                            profiling_success = remote_profiler.wait_for_completion(timeout=60)
+                            profiling_success = remote_profiler.wait_for_completion(
+                                timeout=60
+                            )
                             if profiling_success:
                                 logging.info("Remote profiling completed successfully")
                             else:
-                                logging.warning("Remote profiling did not complete successfully")
+                                logging.warning(
+                                    "Remote profiling did not complete successfully"
+                                )
                         except Exception as e:
-                            logging.error(f"Error waiting for remote profiling completion: {e}")
+                            logging.error(
+                                f"Error waiting for remote profiling completion: {e}"
+                            )
 
                     logging.info("Printing client tool stdout output")
                     if client_container_stdout:
@@ -1835,21 +1902,36 @@ def process_self_contained_coordinator_stream(
                             )
                         elif "vector-db-benchmark" in benchmark_tool:
                             # For vector-db-benchmark, look for summary JSON file
-                            summary_files = [f for f in os.listdir(temporary_dir_client) if f.endswith("-summary.json")]
+                            summary_files = [
+                                f
+                                for f in os.listdir(temporary_dir_client)
+                                if f.endswith("-summary.json")
+                            ]
                             if summary_files:
-                                full_result_path = os.path.join(temporary_dir_client, summary_files[0])
-                                logging.info(f"Found vector-db-benchmark summary file: {summary_files[0]}")
+                                full_result_path = os.path.join(
+                                    temporary_dir_client, summary_files[0]
+                                )
+                                logging.info(
+                                    f"Found vector-db-benchmark summary file: {summary_files[0]}"
+                                )
                             else:
-                                logging.warning("No vector-db-benchmark summary JSON file found")
+                                logging.warning(
+                                    "No vector-db-benchmark summary JSON file found"
+                                )
                                 # Create empty results dict to avoid crash
                                 results_dict = {}
 
                         logging.info(f"Reading results json from {full_result_path}")
 
-                        if "vector-db-benchmark" in benchmark_tool and not os.path.exists(full_result_path):
+                        if (
+                            "vector-db-benchmark" in benchmark_tool
+                            and not os.path.exists(full_result_path)
+                        ):
                             # Handle case where vector-db-benchmark didn't produce results
                             results_dict = {}
-                            logging.warning("Vector-db-benchmark did not produce results file")
+                            logging.warning(
+                                "Vector-db-benchmark did not produce results file"
+                            )
                         else:
                             with open(
                                 full_result_path,
@@ -1990,7 +2072,9 @@ def get_maxmemory(r):
 
     # Check if maxmemory key exists in Redis memory info
     if "maxmemory" not in memory_info:
-        logging.warning("maxmemory not present in Redis memory info. Cannot enforce memory checks.")
+        logging.warning(
+            "maxmemory not present in Redis memory info. Cannot enforce memory checks."
+        )
         return 0
 
     maxmemory = int(memory_info["maxmemory"])
@@ -2085,10 +2169,12 @@ def print_results_table_stdout(
     # Use resolved metric name for precision_summary metrics, otherwise use original path
     def get_display_name(x):
         # For precision_summary metrics with wildcards, construct the resolved path
-        if (len(x) > 1 and
-            isinstance(x[0], str) and
-            "precision_summary" in x[0] and
-            "*" in x[0]):
+        if (
+            len(x) > 1
+            and isinstance(x[0], str)
+            and "precision_summary" in x[0]
+            and "*" in x[0]
+        ):
 
             # Look for the precision level in the cleaned metrics logs
             # We need to find the corresponding cleaned metric to get the precision level
@@ -2097,17 +2183,19 @@ def print_results_table_stdout(
 
             # Since we know from logs that the precision level is available,
             # let's reconstruct it from the metric context path (x[1]) if available
-            if len(x) > 1 and isinstance(x[1], str) and x[1].startswith("'") and x[1].endswith("'"):
+            if (
+                len(x) > 1
+                and isinstance(x[1], str)
+                and x[1].startswith("'")
+                and x[1].endswith("'")
+            ):
                 precision_level = x[1]  # This should be something like "'1.0000'"
                 resolved_path = x[0].replace("*", precision_level)
                 return resolved_path
 
         return x[0]  # Use original path
 
-    results_matrix = [
-        [get_display_name(x), f"{x[3]:.3f}"]
-        for x in results_matrix
-    ]
+    results_matrix = [[get_display_name(x), f"{x[3]:.3f}"] for x in results_matrix]
     writer = MarkdownTableWriter(
         table_name=table_name,
         headers=results_matrix_headers,
@@ -2123,16 +2211,28 @@ def print_redis_info_section(redis_conns):
             redis_info = redis_conns[0].info()
             server_name = "redis"
             if "server_name" in redis_info:
-                server_name = redis_info['server_name']
+                server_name = redis_info["server_name"]
 
             print("\n# Redis Server Information")
             redis_info_data = [
-                [f"{server_name} version", redis_info.get(f"{server_name}_version", "unknown")],
+                [
+                    f"{server_name} version",
+                    redis_info.get(f"{server_name}_version", "unknown"),
+                ],
                 ["redis version", redis_info.get("redis_version", "unknown")],
                 ["io_threads_active", redis_info.get("io_threads_active", "unknown")],
-                [f"{server_name} Git SHA1", redis_info.get("redis_git_sha1", "unknown")],
-                [f"{server_name} Git Dirty", str(redis_info.get("redis_git_dirty", "unknown"))],
-                [f"{server_name} Build ID", redis_info.get("redis_build_id", "unknown")],
+                [
+                    f"{server_name} Git SHA1",
+                    redis_info.get("redis_git_sha1", "unknown"),
+                ],
+                [
+                    f"{server_name} Git Dirty",
+                    str(redis_info.get("redis_git_dirty", "unknown")),
+                ],
+                [
+                    f"{server_name} Build ID",
+                    redis_info.get("redis_build_id", "unknown"),
+                ],
                 [f"{server_name} Mode", redis_info.get("redis_mode", "unknown")],
                 ["OS", redis_info.get("os", "unknown")],
                 ["Arch Bits", str(redis_info.get("arch_bits", "unknown"))],
@@ -2167,7 +2267,9 @@ def get_supported_redis_commands(redis_conns):
         try:
             # Execute COMMAND to get all supported commands
             commands_info = redis_conns[0].execute_command("COMMAND")
-            logging.info(f"COMMAND response type: {type(commands_info)}, length: {len(commands_info) if hasattr(commands_info, '__len__') else 'N/A'}")
+            logging.info(
+                f"COMMAND response type: {type(commands_info)}, length: {len(commands_info) if hasattr(commands_info, '__len__') else 'N/A'}"
+            )
 
             # Extract command names
             supported_commands = set()
@@ -2176,7 +2278,7 @@ def get_supported_redis_commands(redis_conns):
                 # COMMAND response is a dict with command names as keys
                 for cmd_name in commands_info.keys():
                     if isinstance(cmd_name, bytes):
-                        cmd_name = cmd_name.decode('utf-8')
+                        cmd_name = cmd_name.decode("utf-8")
                     supported_commands.add(str(cmd_name).upper())
             elif isinstance(commands_info, (list, tuple)):
                 # Fallback for list format (first element of each command info array)
@@ -2184,10 +2286,12 @@ def get_supported_redis_commands(redis_conns):
                     if isinstance(cmd_info, (list, tuple)) and len(cmd_info) > 0:
                         cmd_name = cmd_info[0]
                         if isinstance(cmd_name, bytes):
-                            cmd_name = cmd_name.decode('utf-8')
+                            cmd_name = cmd_name.decode("utf-8")
                         supported_commands.add(str(cmd_name).upper())
 
-            logging.info(f"Retrieved {len(supported_commands)} supported Redis commands")
+            logging.info(
+                f"Retrieved {len(supported_commands)} supported Redis commands"
+            )
 
             # Log some sample commands for debugging
             if supported_commands:
@@ -2195,7 +2299,9 @@ def get_supported_redis_commands(redis_conns):
                 logging.info(f"Sample commands: {sample_commands}")
 
                 # Check specifically for vector commands
-                vector_commands = [cmd for cmd in supported_commands if cmd.startswith('V')]
+                vector_commands = [
+                    cmd for cmd in supported_commands if cmd.startswith("V")
+                ]
                 if vector_commands:
                     logging.info(f"Vector commands found: {sorted(vector_commands)}")
 
@@ -2255,13 +2361,20 @@ def prepare_overall_total_test_results(
     # Use the same display name logic as in the individual test results
     def get_overall_display_name(x):
         # For precision_summary metrics with wildcards, construct the resolved path
-        if (len(x) > 1 and
-            isinstance(x[0], str) and
-            "precision_summary" in x[0] and
-            "*" in x[0]):
+        if (
+            len(x) > 1
+            and isinstance(x[0], str)
+            and "precision_summary" in x[0]
+            and "*" in x[0]
+        ):
 
             # Reconstruct resolved path from metric context path (x[1]) if available
-            if len(x) > 1 and isinstance(x[1], str) and x[1].startswith("'") and x[1].endswith("'"):
+            if (
+                len(x) > 1
+                and isinstance(x[1], str)
+                and x[1].startswith("'")
+                and x[1].endswith("'")
+            ):
                 precision_level = x[1]  # This should be something like "'1.0000'"
                 resolved_path = x[0].replace("*", precision_level)
                 return resolved_path
@@ -2269,7 +2382,8 @@ def prepare_overall_total_test_results(
         return x[0]  # Use original path
 
     current_test_results_matrix = [
-        [test_name, get_overall_display_name(x), f"{x[3]:.3f}"] for x in current_test_results_matrix
+        [test_name, get_overall_display_name(x), f"{x[3]:.3f}"]
+        for x in current_test_results_matrix
     ]
     overall_results_matrix.extend(current_test_results_matrix)
 
@@ -2317,7 +2431,7 @@ def data_prepopulation_step(
 
     # Set preload tool path based on local install option
     if benchmark_local_install and "memtier_benchmark" in preload_tool and args:
-        full_benchmark_path = getattr(args, 'memtier_bin_path', 'memtier_benchmark')
+        full_benchmark_path = getattr(args, "memtier_bin_path", "memtier_benchmark")
     else:
         full_benchmark_path = f"/usr/local/bin/{preload_tool}"
     client_mnt_point = "/mnt/client/"
@@ -2364,13 +2478,13 @@ def data_prepopulation_step(
             )
 
             # Calculate timeout for preload process
-            process_timeout = calculate_process_timeout(preload_command_str, timeout_buffer)
+            process_timeout = calculate_process_timeout(
+                preload_command_str, timeout_buffer
+            )
 
             # Run with timeout
             success, client_container_stdout, stderr = run_local_command_with_timeout(
-                preload_command_str,
-                process_timeout,
-                "memtier preload"
+                preload_command_str, process_timeout, "memtier preload"
             )
 
             if not success:

{redis_benchmarks_specification-0.1.280.dist-info → redis_benchmarks_specification-0.1.282.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.280
+Version: 0.1.282
 Summary: The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute.
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com

{redis_benchmarks_specification-0.1.280.dist-info → redis_benchmarks_specification-0.1.282.dist-info}/RECORD

@@ -17,15 +17,15 @@ redis_benchmarks_specification/__common__/github.py,sha256=9TZtnISsSgXTSAN_VQejo
 redis_benchmarks_specification/__common__/package.py,sha256=4uVt1BAZ999LV2rZkq--Tk6otAVIf9YR3g3KGeUpiW4,834
 redis_benchmarks_specification/__common__/runner.py,sha256=2IpMl0IEHi2IZvfLc4_h0e-E3ZfnlB8EkCA_SE8VDCY,7033
 redis_benchmarks_specification/__common__/spec.py,sha256=D_SN48wg6NMthW_-OS1H5bydSDiuZpfd4WPPj7Vfwmc,5760
-redis_benchmarks_specification/__common__/timeseries.py,sha256=Jd8kGrLiuIs_1508F0MfiM4qlN_6gZWazG8arHxz9xA,52643
+redis_benchmarks_specification/__common__/timeseries.py,sha256=dae3YF4cX2Css8i5VnOGxAk3DOu8tHfZt-Vy-uiWQDQ,52917
 redis_benchmarks_specification/__compare__/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
-redis_benchmarks_specification/__compare__/args.py,sha256=FlKD1wutBoKxeahpXw1gY2H_1FOPH5y-o5QsIPfFsT0,6802
-redis_benchmarks_specification/__compare__/compare.py,sha256=O6ZuB6Ln5xkTX5jRaizpj1PTPhmoETcf-_PY-A_CGr8,57179
+redis_benchmarks_specification/__compare__/args.py,sha256=shER83ddBRBMAlbgxGXJ5H5XziKe-sP_Nyx7t5aLOo8,7650
+redis_benchmarks_specification/__compare__/compare.py,sha256=8mtvlwQRYR4c4oOji2qP_fOgtOQCKBL3caHplgTEB2M,62214
 redis_benchmarks_specification/__init__.py,sha256=YQIEx2sLPPA0JR9OuCuMNMNtm-f_gqDKgzvNJnkGNKY,491
 redis_benchmarks_specification/__runner__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
-redis_benchmarks_specification/__runner__/args.py,sha256=WAzAck0w_luIRNuc1tY2S45NmP36sSaFESK-CwiJILc,9513
-redis_benchmarks_specification/__runner__/remote_profiling.py,sha256=R4KNm44EGeqdqEkZmxjeKg5qpYVeOC54RyyVDeZijQE,11438
-redis_benchmarks_specification/__runner__/runner.py,sha256=K_YthEGoEX66b0kEAKvWLfjSXq86SJUGyOof33qqo64,99489
+redis_benchmarks_specification/__runner__/args.py,sha256=4NaHTfT3FB0wGrYslWb_DKHGf9Za963TjXKk648cjqw,9679
+redis_benchmarks_specification/__runner__/remote_profiling.py,sha256=oTcV_GbtduUE2jnodkLBmnyO53Kgralvi08peLKMXYk,12030
+redis_benchmarks_specification/__runner__/runner.py,sha256=l0h2uCEtQkkzlP8fHlY4BwnBTm1ysu0u52OgiHOsLNo,102241
 redis_benchmarks_specification/__self_contained_coordinator__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
 redis_benchmarks_specification/__self_contained_coordinator__/args.py,sha256=uxBjdQ78klvsVi6lOfGYQVaWIxc8OI-DwYKY16SgvCY,5952
 redis_benchmarks_specification/__self_contained_coordinator__/artifacts.py,sha256=OVHqJzDgeSSRfUSiKp1ZTAVv14PvSbk-5yJsAAoUfpw,936
@@ -273,8 +273,8 @@ redis_benchmarks_specification/test-suites/memtier_benchmark-nokeys-pubsub-publi
 redis_benchmarks_specification/test-suites/memtier_benchmark-nokeys-server-time-pipeline-10.yml,sha256=rJuWWXubUeRKQ2GSfHlbPMLeOyM9Eu_MzvN2vgKcAhA,672
 redis_benchmarks_specification/test-suites/template.txt,sha256=d_edIE7Sxa5X7I2yG-Io0bPdbDIHR0oWFoCA3XUt_EU,435
 redis_benchmarks_specification/vector-search-test-suites/vector_db_benchmark_test.yml,sha256=uhaSP6YUVmPvZU-qMtPPGdvNEUgUBqOfveUbeJ9WsbI,972
-redis_benchmarks_specification-0.1.280.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-redis_benchmarks_specification-0.1.280.dist-info/METADATA,sha256=UPoVBQeNRKQj1xsJNi8NYYu6LXbO3rwNo41HFPN14Io,22726
-redis_benchmarks_specification-0.1.280.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-redis_benchmarks_specification-0.1.280.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
-redis_benchmarks_specification-0.1.280.dist-info/RECORD,,
+redis_benchmarks_specification-0.1.282.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+redis_benchmarks_specification-0.1.282.dist-info/METADATA,sha256=iPeWrG4jBoFKIZ3uGvr_lNUA4w6MgexW1sk8jCKhzjc,22726
+redis_benchmarks_specification-0.1.282.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+redis_benchmarks_specification-0.1.282.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
+redis_benchmarks_specification-0.1.282.dist-info/RECORD,,