redis-benchmarks-specification 0.1.281__py3-none-any.whl → 0.1.283__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)
 
@@ -1089,6 +1125,7 @@ def process_self_contained_coordinator_stream(
                     current_cpu_pos = args.cpuset_start_pos
                     temporary_dir_client = tempfile.mkdtemp(dir=home)
 
+                    # These will be updated after auto-detection
                     tf_github_org = args.github_org
                     tf_github_repo = args.github_repo
                     tf_triggering_env = args.platform_name
@@ -1121,6 +1158,56 @@ def process_self_contained_coordinator_stream(
                     )
                     setup_name = "oss-standalone"
                     r.ping()
+
+                    # Auto-detect server information if not explicitly provided
+                    from redis_benchmarks_specification.__runner__.remote_profiling import (
+                        extract_server_info_for_args,
+                        extract_server_metadata_for_timeseries
+                    )
+
+                    detected_info = extract_server_info_for_args(r)
+                    server_metadata = extract_server_metadata_for_timeseries(r)
+
+                    # Use detected values if arguments weren't explicitly provided
+                    github_org = args.github_org
+                    github_repo = args.github_repo
+
+                    # Auto-detect github_org if it's the default value
+                    if args.github_org == "redis" and detected_info["github_org"] != "redis":
+                        github_org = detected_info["github_org"]
+                        logging.info(f"Auto-detected github_org: {github_org}")
+
+                    # Auto-detect github_repo if it's the default value
+                    if args.github_repo == "redis" and detected_info["github_repo"] != "redis":
+                        github_repo = detected_info["github_repo"]
+                        logging.info(f"Auto-detected github_repo: {github_repo}")
+
+                    # Auto-detect version if it's the default value
+                    if args.github_version == "NA" and detected_info["github_version"] != "unknown":
+                        git_version = detected_info["github_version"]
+                        logging.info(f"Auto-detected github_version: {git_version}")
+
+                    # Auto-detect git hash from server info if available
+                    if git_hash == "NA":
+                        try:
+                            server_info = r.info("server")
+                            redis_git_sha1 = server_info.get("redis_git_sha1", "")
+                            redis_build_id = server_info.get("redis_build_id", "")
+
+                            # Use git_sha1 if available and not empty/zero
+                            if redis_git_sha1 and redis_git_sha1 not in ("", "0", "00000000"):
+                                git_hash = redis_git_sha1
+                                logging.info(f"Auto-detected git_hash from redis_git_sha1: {git_hash}")
+                            # Fallback to build_id if git_sha1 is not available
+                            elif redis_build_id and redis_build_id not in ("", "0"):
+                                git_hash = redis_build_id
+                                logging.info(f"Auto-detected git_hash from redis_build_id: {git_hash}")
+                        except Exception as e:
+                            logging.warning(f"Failed to auto-detect git hash: {e}")
+
+                    # Update tf_github_org and tf_github_repo with detected values
+                    tf_github_org = github_org
+                    tf_github_repo = github_repo
                     redis_conns = [r]
                     if oss_cluster_api_enabled:
                         redis_conns = []
@@ -1156,8 +1243,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:
@@ -1235,6 +1322,8 @@ def process_self_contained_coordinator_stream(
                     benchmark_tool_workdir = client_mnt_point
 
                     metadata = {}
+                    # Add server metadata from Redis INFO SERVER
+                    metadata.update(server_metadata)
                     test_tls_cacert = None
                     test_tls_cert = None
                     test_tls_key = None
@@ -1328,7 +1417,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 +1490,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 +1662,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 +1674,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 +1736,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 +1776,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 +1809,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 +1875,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 +1955,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,
@@ -1897,6 +2032,7 @@ def process_self_contained_coordinator_stream(
                         tf_triggering_env,
                         topology_spec_name,
                         default_metrics,
+                        git_hash,
                     )
                     test_result = True
                     total_test_suite_runs = total_test_suite_runs + 1
@@ -1990,7 +2126,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 +2223,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 +2237,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 +2265,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 +2321,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 +2332,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 +2340,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 +2353,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 +2415,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 +2436,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 +2485,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 +2532,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.281.dist-info → redis_benchmarks_specification-0.1.283.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.281
+Version: 0.1.283
 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