⚡️ Speed up method PipelineRuntimeConfigBuilder._get_vertex_value by 2,895%

[codeflash-ai]

📄 2,895% (28.95x) speedup for PipelineRuntimeConfigBuilder._get_vertex_value in google/cloud/aiplatform/utils/pipeline_utils.py

⏱️ Runtime : 16.3 milliseconds → 544 microseconds (best of 242 runs)

📝 Explanation and details

The optimization achieves a massive 2894% speedup by eliminating a critical performance bottleneck: repeated version string parsing and comparison.

Key Optimization:

• Cached version comparison: The expensive packaging.version.parse(self._schema_version) <= packaging.version.parse("2.0.0") operation was being executed on every single call to _get_vertex_value(). The optimization moves this to __init__ and caches the result as self._is_legacy_schema.

Why this matters:

• Version parsing involves string tokenization, normalization, and object creation - expensive operations that were happening thousands of times
• Line profiler shows the version comparison took 95.2% of total execution time (58.98ms out of 61.97ms)
• After optimization, this drops to just 17.2% of a much smaller total time

Performance benefits by use case:

• Basic operations (single calls): 1500-3400% faster, reducing ~13-17μs calls to ~400-800ns
• Large scale operations (100+ parameters): 2500-3500% faster, reducing ~650μs to ~25μs
• Edge cases with exceptions: 500-600% faster for error paths that still need the version check

The optimization maintains identical behavior and error handling while transforming a O(n) per-call cost into a O(1) initialization cost, making it especially valuable for pipeline configurations with many parameters.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 2499 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import copy
from typing import Any, Dict, Mapping, Optional, Union

import packaging.version
# imports
import pytest  # used for our unit tests
from aiplatform.utils.pipeline_utils import PipelineRuntimeConfigBuilder

# unit tests

# Helper function to create a builder with given parameter types and schema version
def make_builder(schema_version, parameter_types):
    return PipelineRuntimeConfigBuilder(
        pipeline_root="dummy-root",
        schema_version=schema_version,
        parameter_types=parameter_types
    )

# --------------------
# 1. Basic Test Cases
# --------------------

def test_int_value_basic():
    # INT type, schema_version <= 2.0.0
    builder = make_builder("2.0.0", {"param1": "INT"})
    codeflash_output = builder._get_vertex_value("param1", 42); result = codeflash_output # 17.1μs -> 743ns (2201% faster)

def test_double_value_basic():
    # DOUBLE type, schema_version <= 2.0.0
    builder = make_builder("2.0.0", {"param2": "DOUBLE"})
    codeflash_output = builder._get_vertex_value("param2", 3.14); result = codeflash_output # 14.3μs -> 755ns (1798% faster)

def test_string_value_basic():
    # STRING type, schema_version <= 2.0.0
    builder = make_builder("2.0.0", {"param3": "STRING"})
    codeflash_output = builder._get_vertex_value("param3", "hello"); result = codeflash_output # 14.3μs -> 817ns (1649% faster)

def test_int_value_new_schema():
    # INT type, schema_version > 2.0.0
    builder = make_builder("2.0.1", {"param1": "INT"})
    codeflash_output = builder._get_vertex_value("param1", 42); result = codeflash_output # 13.6μs -> 441ns (2985% faster)

def test_double_value_new_schema():
    # DOUBLE type, schema_version > 2.0.0
    builder = make_builder("2.1.0", {"param2": "DOUBLE"})
    codeflash_output = builder._get_vertex_value("param2", 3.14); result = codeflash_output # 13.5μs -> 420ns (3113% faster)

def test_string_value_new_schema():
    # STRING type, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param3": "STRING"})
    codeflash_output = builder._get_vertex_value("param3", "hello"); result = codeflash_output # 13.6μs -> 389ns (3406% faster)

def test_list_value_new_schema():
    # List value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param4": "STRING"})
    value = [1, 2, 3]
    codeflash_output = builder._get_vertex_value("param4", value); result = codeflash_output # 13.3μs -> 404ns (3197% faster)

def test_dict_value_new_schema():
    # Dict value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param5": "STRING"})
    value = {"a": 1, "b": 2}
    codeflash_output = builder._get_vertex_value("param5", value); result = codeflash_output # 13.3μs -> 416ns (3094% faster)

def test_bool_value_new_schema():
    # Boolean value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param6": "STRING"})
    value = True
    codeflash_output = builder._get_vertex_value("param6", value); result = codeflash_output # 13.3μs -> 421ns (3061% faster)

# --------------------
# 2. Edge Test Cases
# --------------------

def test_none_value_raises():
    # Value is None, should raise ValueError
    builder = make_builder("2.0.0", {"param1": "INT"})
    with pytest.raises(ValueError, match="None values should be filtered out."):
        builder._get_vertex_value("param1", None) # 874ns -> 786ns (11.2% faster)

def test_missing_parameter_name_raises():
    # Name not in parameter_types, should raise ValueError
    builder = make_builder("2.0.0", {"param1": "INT"})
    with pytest.raises(ValueError, match="pipeline parameter missing_param is not found"):
        builder._get_vertex_value("missing_param", 123) # 1.58μs -> 1.54μs (2.46% faster)

def test_unknown_type_raises():
    # Unknown type in parameter_types, should raise TypeError
    builder = make_builder("2.0.0", {"param1": "BOOL"})
    with pytest.raises(TypeError, match="Got unknown type of value"):
        builder._get_vertex_value("param1", True) # 17.2μs -> 2.32μs (640% faster)

def test_schema_version_boundary():
    # schema_version exactly "2.0.0" uses proto message
    builder = make_builder("2.0.0", {"param1": "STRING"})
    codeflash_output = builder._get_vertex_value("param1", "test"); result = codeflash_output # 14.6μs -> 876ns (1561% faster)

def test_schema_version_just_above_boundary():
    # schema_version just above "2.0.0" uses raw value
    builder = make_builder("2.0.1", {"param1": "STRING"})
    codeflash_output = builder._get_vertex_value("param1", "test"); result = codeflash_output # 14.1μs -> 432ns (3175% faster)

def test_empty_string_value():
    # Empty string value
    builder = make_builder("2.0.0", {"param1": "STRING"})
    codeflash_output = builder._get_vertex_value("param1", ""); result = codeflash_output # 13.4μs -> 801ns (1576% faster)

def test_zero_int_value():
    # Zero integer value
    builder = make_builder("2.0.0", {"param1": "INT"})
    codeflash_output = builder._get_vertex_value("param1", 0); result = codeflash_output # 13.4μs -> 664ns (1920% faster)

def test_negative_double_value():
    # Negative double value
    builder = make_builder("2.0.0", {"param1": "DOUBLE"})
    codeflash_output = builder._get_vertex_value("param1", -123.456); result = codeflash_output # 13.5μs -> 721ns (1778% faster)

def test_large_int_value():
    # Large integer value
    builder = make_builder("2.0.0", {"param1": "INT"})
    large_int = 10**18
    codeflash_output = builder._get_vertex_value("param1", large_int); result = codeflash_output # 13.4μs -> 640ns (1998% faster)

def test_float_value_for_int_type():
    # Float value for INT type, should not raise (no type check on value)
    builder = make_builder("2.0.0", {"param1": "INT"})
    codeflash_output = builder._get_vertex_value("param1", 3.0); result = codeflash_output # 13.3μs -> 648ns (1958% faster)

def test_int_value_for_double_type():
    # Int value for DOUBLE type, should not raise (no type check on value)
    builder = make_builder("2.0.0", {"param1": "DOUBLE"})
    codeflash_output = builder._get_vertex_value("param1", 7); result = codeflash_output # 13.3μs -> 680ns (1852% faster)

def test_bool_value_for_string_type():
    # Boolean value for STRING type, should not raise (no type check on value)
    builder = make_builder("2.0.0", {"param1": "STRING"})
    codeflash_output = builder._get_vertex_value("param1", False); result = codeflash_output # 13.4μs -> 790ns (1593% faster)

def test_empty_parameter_types():
    # Empty parameter_types, should raise ValueError
    builder = make_builder("2.0.0", {})
    with pytest.raises(ValueError):
        builder._get_vertex_value("param1", "test") # 1.63μs -> 1.68μs (2.97% slower)

def test_parameter_types_with_extra_types():
    # parameter_types includes extra types, should ignore them unless used
    builder = make_builder("2.0.0", {"param1": "STRING", "param2": "EXTRA"})
    codeflash_output = builder._get_vertex_value("param1", "abc"); result = codeflash_output # 15.3μs -> 818ns (1767% faster)
    with pytest.raises(TypeError):
        builder._get_vertex_value("param2", "abc") # 9.47μs -> 1.31μs (625% faster)

# --------------------
# 3. Large Scale Test Cases
# --------------------

def test_many_parameters_proto_message():
    # Many parameters, schema_version <= 2.0.0
    parameter_types = {f"int_param_{i}": "INT" for i in range(100)}
    builder = make_builder("2.0.0", parameter_types)
    for i in range(100):
        codeflash_output = builder._get_vertex_value(f"int_param_{i}", i); result = codeflash_output # 670μs -> 24.7μs (2616% faster)

def test_many_parameters_new_schema():
    # Many parameters, schema_version > 2.0.0
    parameter_types = {f"str_param_{i}": "STRING" for i in range(100)}
    builder = make_builder("3.0.0", parameter_types)
    for i in range(100):
        value = f"value_{i}"
        codeflash_output = builder._get_vertex_value(f"str_param_{i}", value); result = codeflash_output # 658μs -> 17.9μs (3578% faster)

def test_large_list_value_new_schema():
    # Large list value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param": "STRING"})
    large_list = list(range(1000))
    codeflash_output = builder._get_vertex_value("param", large_list); result = codeflash_output # 13.5μs -> 439ns (2975% faster)

def test_large_dict_value_new_schema():
    # Large dict value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param": "STRING"})
    large_dict = {str(i): i for i in range(1000)}
    codeflash_output = builder._get_vertex_value("param", large_dict); result = codeflash_output # 13.8μs -> 425ns (3137% faster)

def test_many_parameters_mixed_types_proto_message():
    # Many parameters with mixed types, schema_version <= 2.0.0
    parameter_types = {}
    for i in range(30):
        parameter_types[f"int_param_{i}"] = "INT"
        parameter_types[f"double_param_{i}"] = "DOUBLE"
        parameter_types[f"str_param_{i}"] = "STRING"
    builder = make_builder("2.0.0", parameter_types)
    for i in range(30):
        codeflash_output = builder._get_vertex_value(f"int_param_{i}", i) # 204μs -> 7.84μs (2511% faster)
        codeflash_output = builder._get_vertex_value(f"double_param_{i}", float(i))
        codeflash_output = builder._get_vertex_value(f"str_param_{i}", str(i)) # 203μs -> 8.78μs (2215% faster)

def test_many_parameters_mixed_types_new_schema():
    # Many parameters with mixed types, schema_version > 2.0.0
    parameter_types = {}
    for i in range(30):
        parameter_types[f"int_param_{i}"] = "INT"
        parameter_types[f"double_param_{i}"] = "DOUBLE"
        parameter_types[f"str_param_{i}"] = "STRING"
    builder = make_builder("3.0.0", parameter_types)
    for i in range(30):
        codeflash_output = builder._get_vertex_value(f"int_param_{i}", i) # 201μs -> 5.60μs (3493% faster)
        codeflash_output = builder._get_vertex_value(f"double_param_{i}", float(i))
        codeflash_output = builder._get_vertex_value(f"str_param_{i}", str(i)) # 195μs -> 5.61μs (3379% faster)

def test_large_int_value_new_schema():
    # Large integer value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param": "INT"})
    large_int = 10**18
    codeflash_output = builder._get_vertex_value("param", large_int); result = codeflash_output # 13.3μs -> 393ns (3275% faster)

def test_large_double_value_new_schema():
    # Large double value, schema_version > 2.0.0
    builder = make_builder("3.0.0", {"param": "DOUBLE"})
    large_double = 1.7976931348623157e+308  # max float
    codeflash_output = builder._get_vertex_value("param", large_double); result = codeflash_output # 12.7μs -> 384ns (3205% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import copy
from typing import Any, Dict, Mapping, Optional, Union

import packaging.version
# imports
import pytest  # used for our unit tests
from aiplatform.utils.pipeline_utils import PipelineRuntimeConfigBuilder

# unit tests

# ---- Basic Test Cases ----

def test_int_value_basic():
    # Test INT type with schema_version <= 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    codeflash_output = builder._get_vertex_value("param1", 42); result = codeflash_output # 12.9μs -> 654ns (1878% faster)

def test_double_value_basic():
    # Test DOUBLE type with schema_version <= 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param2": "DOUBLE"}
    )
    codeflash_output = builder._get_vertex_value("param2", 3.14); result = codeflash_output # 12.9μs -> 692ns (1769% faster)

def test_string_value_basic():
    # Test STRING type with schema_version <= 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param3": "STRING"}
    )
    codeflash_output = builder._get_vertex_value("param3", "hello"); result = codeflash_output # 13.0μs -> 770ns (1593% faster)

def test_schema_version_greater_than_2_returns_value_directly():
    # Test that schema_version > 2.0.0 returns value directly
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.1.0",
        parameter_types={"param1": "INT"}
    )
    value = 123
    codeflash_output = builder._get_vertex_value("param1", value); result = codeflash_output # 12.8μs -> 411ns (3024% faster)

def test_schema_version_greater_than_2_returns_string_directly():
    # Test STRING type with schema_version > 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types={"param3": "STRING"}
    )
    value = "world"
    codeflash_output = builder._get_vertex_value("param3", value); result = codeflash_output # 12.7μs -> 373ns (3306% faster)

def test_schema_version_greater_than_2_returns_float_directly():
    # Test DOUBLE type with schema_version > 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.5.0",
        parameter_types={"param2": "DOUBLE"}
    )
    value = 8.88
    codeflash_output = builder._get_vertex_value("param2", value); result = codeflash_output # 13.1μs -> 415ns (3060% faster)

# ---- Edge Test Cases ----

def test_missing_parameter_name_raises_value_error():
    # Test missing parameter name in parameter_types raises ValueError
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    with pytest.raises(ValueError) as excinfo:
        builder._get_vertex_value("unknown_param", 10) # 1.57μs -> 1.59μs (1.57% slower)

def test_none_value_raises_value_error():
    # Test None value raises ValueError
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    with pytest.raises(ValueError) as excinfo:
        builder._get_vertex_value("param1", None) # 782ns -> 739ns (5.82% faster)

def test_unknown_type_raises_type_error():
    # Test unknown type in parameter_types raises TypeError
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"paramX": "BOOL"}
    )
    with pytest.raises(TypeError) as excinfo:
        builder._get_vertex_value("paramX", True) # 16.9μs -> 2.47μs (586% faster)

def test_string_type_with_int_value():
    # Test STRING type with int value, should still wrap as stringValue
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param3": "STRING"}
    )
    codeflash_output = builder._get_vertex_value("param3", 123); result = codeflash_output # 13.9μs -> 818ns (1597% faster)

def test_int_type_with_float_value():
    # Test INT type with float value, should wrap as intValue (no type enforcement)
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    codeflash_output = builder._get_vertex_value("param1", 7.0); result = codeflash_output # 14.0μs -> 611ns (2189% faster)

def test_double_type_with_int_value():
    # Test DOUBLE type with int value, should wrap as doubleValue
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param2": "DOUBLE"}
    )
    codeflash_output = builder._get_vertex_value("param2", 5); result = codeflash_output # 13.5μs -> 713ns (1796% faster)

def test_schema_version_as_exact_2_returns_dict():
    # Test schema_version as "2.0.0" returns dict
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    codeflash_output = builder._get_vertex_value("param1", 99); result = codeflash_output # 13.8μs -> 626ns (2111% faster)

def test_schema_version_as_2_0_returns_dict():
    # Test schema_version as "2.0" returns dict
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0",
        parameter_types={"param1": "INT"}
    )
    codeflash_output = builder._get_vertex_value("param1", 100); result = codeflash_output # 14.0μs -> 647ns (2070% faster)

def test_schema_version_as_2_0_1_returns_value():
    # Test schema_version as "2.0.1" returns value directly
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.1",
        parameter_types={"param1": "INT"}
    )
    value = 101
    codeflash_output = builder._get_vertex_value("param1", value); result = codeflash_output # 13.7μs -> 443ns (2985% faster)

def test_schema_version_as_1_9_9_returns_dict():
    # Test schema_version as "1.9.9" returns dict
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="1.9.9",
        parameter_types={"param1": "INT"}
    )
    codeflash_output = builder._get_vertex_value("param1", 77); result = codeflash_output # 13.8μs -> 627ns (2099% faster)

def test_empty_string_value():
    # Test STRING type with empty string value
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param3": "STRING"}
    )
    codeflash_output = builder._get_vertex_value("param3", ""); result = codeflash_output # 13.9μs -> 746ns (1766% faster)

def test_zero_int_value():
    # Test INT type with zero value
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    codeflash_output = builder._get_vertex_value("param1", 0); result = codeflash_output # 13.0μs -> 652ns (1900% faster)

def test_zero_double_value():
    # Test DOUBLE type with zero value
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param2": "DOUBLE"}
    )
    codeflash_output = builder._get_vertex_value("param2", 0.0); result = codeflash_output # 13.4μs -> 685ns (1850% faster)

def test_large_int_value():
    # Test INT type with a large integer value
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param1": "INT"}
    )
    large_value = 2**62
    codeflash_output = builder._get_vertex_value("param1", large_value); result = codeflash_output # 13.1μs -> 624ns (2001% faster)

def test_large_double_value():
    # Test DOUBLE type with a large float value
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param2": "DOUBLE"}
    )
    large_value = 1.7e308
    codeflash_output = builder._get_vertex_value("param2", large_value); result = codeflash_output # 13.3μs -> 675ns (1878% faster)

# ---- Large Scale Test Cases ----

def test_many_parameters_schema_v2():
    # Test with many parameters (up to 1000) and schema_version <= 2.0.0
    param_types = {f"p{i}": "INT" for i in range(1000)}
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types=param_types
    )
    for i in range(1000):
        codeflash_output = builder._get_vertex_value(f"p{i}", i); result = codeflash_output # 6.55ms -> 238μs (2651% faster)

def test_many_parameters_schema_v3():
    # Test with many parameters (up to 1000) and schema_version > 2.0.0
    param_types = {f"p{i}": "STRING" for i in range(1000)}
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types=param_types
    )
    for i in range(1000):
        value = f"value_{i}"
        codeflash_output = builder._get_vertex_value(f"p{i}", value); result = codeflash_output # 6.49ms -> 176μs (3583% faster)

def test_large_string_value():
    # Test STRING type with a very large string value
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param3": "STRING"}
    )
    large_string = "x" * 1000
    codeflash_output = builder._get_vertex_value("param3", large_string); result = codeflash_output # 16.3μs -> 916ns (1678% faster)

def test_large_list_value_schema_v3():
    # Test passing a large list as value with schema_version > 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types={"param_list": "STRING"}
    )
    large_list = list(range(1000))
    codeflash_output = builder._get_vertex_value("param_list", large_list); result = codeflash_output # 13.5μs -> 472ns (2766% faster)

def test_large_dict_value_schema_v3():
    # Test passing a large dict as value with schema_version > 2.0.0
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types={"param_dict": "STRING"}
    )
    large_dict = {str(i): i for i in range(1000)}
    codeflash_output = builder._get_vertex_value("param_dict", large_dict); result = codeflash_output # 14.3μs -> 412ns (3377% faster)

# ---- Additional Edge Cases ----

def test_bool_type_with_schema_v3():
    # Test passing a bool value with schema_version > 2.0.0 (should return directly)
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types={"param_bool": "BOOL"}
    )
    codeflash_output = builder._get_vertex_value("param_bool", True); result = codeflash_output # 13.5μs -> 389ns (3373% faster)

def test_bool_type_with_schema_v2_raises_type_error():
    # Test passing a bool value with schema_version <= 2.0.0 (should raise TypeError)
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"param_bool": "BOOL"}
    )
    with pytest.raises(TypeError):
        builder._get_vertex_value("param_bool", False) # 15.2μs -> 2.48μs (513% faster)

def test_list_type_with_schema_v3():
    # Test passing a list value with schema_version > 2.0.0 (should return directly)
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types={"param_list": "LIST"}
    )
    test_list = [1, 2, 3]
    codeflash_output = builder._get_vertex_value("param_list", test_list); result = codeflash_output # 13.3μs -> 472ns (2722% faster)

def test_dict_type_with_schema_v3():
    # Test passing a dict value with schema_version > 2.0.0 (should return directly)
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="3.0.0",
        parameter_types={"param_dict": "DICT"}
    )
    test_dict = {"a": 1, "b": 2}
    codeflash_output = builder._get_vertex_value("param_dict", test_dict); result = codeflash_output # 13.2μs -> 409ns (3125% faster)

def test_parameter_types_case_sensitive():
    # Test that parameter name matching is case sensitive
    builder = PipelineRuntimeConfigBuilder(
        pipeline_root="root",
        schema_version="2.0.0",
        parameter_types={"Param1": "INT"}
    )
    with pytest.raises(ValueError):
        builder._get_vertex_value("param1", 1) # 1.55μs -> 1.52μs (2.31% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-PipelineRuntimeConfigBuilder._get_vertex_value-mgik9vkn and push.