⚡️ Speed up method PipelineRuntimeConfigBuilder.from_job_spec_json by 322%

[codeflash-ai]

📄 322% (3.22x) speedup for PipelineRuntimeConfigBuilder.from_job_spec_json in google/cloud/aiplatform/utils/pipeline_utils.py

⏱️ Runtime : 2.31 milliseconds → 547 microseconds (best of 588 runs)

📝 Explanation and details

The optimized code achieves a 321% speedup through several key performance improvements:

1. Eliminated Expensive Deep Copies
The original code used copy.deepcopy() for parameter_values and input_artifacts dictionaries in the constructor, which is extremely expensive. The optimization replaces this with shallow copying using dict() constructor when values exist, or empty dict when None. Since these typically contain primitive values (strings, numbers), shallow copying is sufficient and much faster.

2. Reduced Dictionary Lookups
In from_job_spec_json(), the original code performed multiple nested dictionary lookups:

job_spec["pipelineSpec"]["root"].get("inputDefinitions", {}).get("parameters", {})

The optimization extracts pipeline_spec once and chains the lookups more efficiently, reducing redundant dictionary access overhead.

3. Optimized String Key Lookups
In _parse_runtime_parameters(), the optimization pre-defines string keys (intkey, doublekey, strkey) as local variables rather than using string literals in each iteration. This eliminates repeated string object creation and improves lookup performance in the hot loop.

4. Cached Function Call Results
The optimization stores runtime_config_spec.get("parameterValues") and runtime_config_spec.get("parameters") in variables rather than calling .get() multiple times, reducing function call overhead.

Performance Impact by Test Case:

• Basic cases see 94-158% speedup due to eliminated deep copies
• Large scale cases see dramatic improvements (226-529% faster) where the string key optimization and reduced dictionary lookups compound across hundreds/thousands of parameters
• Edge cases maintain similar speedups, showing the optimizations don't compromise correctness

The optimizations are particularly effective for workloads with many parameters or frequent pipeline configuration parsing, which is common in ML pipeline orchestration.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 60 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

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

# unit tests

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

def test_basic_parameter_values():
    """Test basic functionality with 'parameterValues' and 'parameterType'."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/path",
            "parameterValues": {
                "param1": 42,
                "param2": "hello",
                "param3": 3.14,
            },
            "failurePolicy": "FAIL_FAST"
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "param1": {"parameterType": "INT"},
                        "param2": {"parameterType": "STRING"},
                        "param3": {"parameterType": "DOUBLE"},
                    }
                }
            },
            "schemaVersion": "v2"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 8.10μs -> 3.14μs (158% faster)

def test_basic_parameters_deprecated_type():
    """Test with deprecated 'type' instead of 'parameterType'."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/path2",
            "parameterValues": {
                "x": 1,
                "y": "abc",
            }
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "x": {"type": "INT"},
                        "y": {"type": "STRING"},
                    }
                }
            },
            "schemaVersion": "v1"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 7.54μs -> 3.07μs (146% faster)

def test_basic_parameters_old_format():
    """Test with old 'parameters' format using intValue, doubleValue, stringValue."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/path3",
            "parameters": {
                "a": {"intValue": "123"},
                "b": {"doubleValue": "2.718"},
                "c": {"stringValue": "world"},
            }
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "a": {"parameterType": "INT"},
                        "b": {"parameterType": "DOUBLE"},
                        "c": {"parameterType": "STRING"},
                    }
                }
            },
            "schemaVersion": "v3"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 9.19μs -> 4.73μs (94.4% faster)

def test_basic_no_parameters():
    """Test with no parameters present."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/no_params"
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {}
                }
            },
            "schemaVersion": "v4"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 5.56μs -> 2.51μs (122% faster)

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

def test_edge_missing_gcs_output_directory():
    """Test when 'gcsOutputDirectory' is missing in runtimeConfig."""
    job_spec = {
        "runtimeConfig": {
            "parameterValues": {"foo": "bar"}
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {"foo": {"parameterType": "STRING"}}
                }
            },
            "schemaVersion": "v5"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 6.45μs -> 2.78μs (132% faster)

def test_edge_missing_parameter_types():
    """Test when parameters are present but no type info."""
    job_spec = {
        "runtimeConfig": {
            "parameterValues": {"foo": 1}
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {"foo": {}}
                }
            },
            "schemaVersion": "v6"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 6.34μs -> 2.77μs (129% faster)

def test_edge_missing_parameters_and_parameterValues():
    """Test when neither 'parameters' nor 'parameterValues' is present."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/edge"
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {"foo": {"parameterType": "STRING"}}
                }
            },
            "schemaVersion": "v7"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 5.96μs -> 2.58μs (131% faster)

def test_edge_empty_job_spec():
    """Test with completely empty job spec."""
    job_spec = {
        "runtimeConfig": {},
        "pipelineSpec": {
            "root": {},
            "schemaVersion": ""
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 5.64μs -> 2.67μs (112% faster)

def test_edge_type_error_on_unknown_parameter_type():
    """Test with unknown parameter type in old 'parameters' format."""
    job_spec = {
        "runtimeConfig": {
            "parameters": {
                "foo": {"unknownValue": "???"},
            }
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {"foo": {"parameterType": "STRING"}}
                }
            },
            "schemaVersion": "v8"
        }
    }
    with pytest.raises(TypeError):
        PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec) # 4.82μs -> 4.86μs (0.884% slower)

def test_edge_parameter_values_overrides_parameters():
    """Test that 'parameterValues' takes precedence over 'parameters'."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/edge2",
            "parameterValues": {"foo": "bar"},
            "parameters": {
                "foo": {"stringValue": "baz"}
            }
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {"foo": {"parameterType": "STRING"}}
                }
            },
            "schemaVersion": "v9"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 7.04μs -> 3.00μs (134% faster)

def test_edge_failure_policy_none():
    """Test when failurePolicy is missing."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/fp_none",
            "parameterValues": {"foo": 7}
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {"foo": {"parameterType": "INT"}}
                }
            },
            "schemaVersion": "v10"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 6.55μs -> 2.81μs (133% faster)

def test_edge_parameter_values_type_coercion():
    """Test that int and float values are properly coerced from strings."""
    job_spec = {
        "runtimeConfig": {
            "parameters": {
                "int_param": {"intValue": "99"},
                "float_param": {"doubleValue": "1.2345"},
                "str_param": {"stringValue": "teststr"},
            }
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "int_param": {"parameterType": "INT"},
                        "float_param": {"parameterType": "DOUBLE"},
                        "str_param": {"parameterType": "STRING"},
                    }
                }
            },
            "schemaVersion": "v11"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 9.26μs -> 4.72μs (96.0% faster)

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

def test_large_scale_many_parameters():
    """Test with a large number of parameters (up to 1000)."""
    num_params = 1000
    param_defs = {f"p{i}": {"parameterType": "INT"} for i in range(num_params)}
    param_vals = {f"p{i}": i for i in range(num_params)}
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large",
            "parameterValues": param_vals
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": param_defs
                }
            },
            "schemaVersion": "v12"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 390μs -> 62.2μs (529% faster)

def test_large_scale_many_parameters_old_format():
    """Test with a large number of parameters using old 'parameters' format."""
    num_params = 500
    param_defs = {f"p{i}": {"parameterType": "DOUBLE"} for i in range(num_params)}
    param_vals = {f"p{i}": {"doubleValue": str(i + 0.5)} for i in range(num_params)}
    job_spec = {
        "runtimeConfig": {
            "parameters": param_vals
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": param_defs
                }
            },
            "schemaVersion": "v13"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 249μs -> 81.7μs (205% faster)
    expected_values = {f"p{i}": float(i + 0.5) for i in range(num_params)}

def test_large_scale_mixed_types():
    """Test with a large number of parameters of mixed types."""
    num_params = 200
    param_defs = {}
    param_vals = {}
    expected = {}
    for i in range(num_params):
        if i % 3 == 0:
            param_defs[f"p{i}"] = {"parameterType": "INT"}
            param_vals[f"p{i}"] = i
            expected[f"p{i}"] = i
        elif i % 3 == 1:
            param_defs[f"p{i}"] = {"parameterType": "DOUBLE"}
            param_vals[f"p{i}"] = float(i) + 0.1
            expected[f"p{i}"] = float(i) + 0.1
        else:
            param_defs[f"p{i}"] = {"parameterType": "STRING"}
            param_vals[f"p{i}"] = f"str{i}"
            expected[f"p{i}"] = f"str{i}"
    job_spec = {
        "runtimeConfig": {
            "parameterValues": param_vals
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": param_defs
                }
            },
            "schemaVersion": "v14"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 86.6μs -> 15.9μs (446% faster)

def test_large_scale_empty_parameters():
    """Test with large input but no parameters."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large_empty"
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {}
                }
            },
            "schemaVersion": "v15"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 5.97μs -> 2.64μs (126% faster)

def test_large_scale_failure_policy():
    """Test large scale with failurePolicy set."""
    num_params = 100
    param_defs = {f"p{i}": {"parameterType": "STRING"} for i in range(num_params)}
    param_vals = {f"p{i}": f"val{i}" for i in range(num_params)}
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large_fp",
            "parameterValues": param_vals,
            "failurePolicy": "FAIL_SLOW"
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": param_defs
                }
            },
            "schemaVersion": "v16"
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 46.5μs -> 9.25μs (403% 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

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

# function to test
# -*- coding: utf-8 -*-
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#


# Dummy pipeline_failure_policy for testing
class DummyPipelineFailurePolicy:
    PIPELINE_FAILURE_POLICY_FAIL_SLOW = "FAIL_SLOW"
    PIPELINE_FAILURE_POLICY_FAIL_FAST = "FAIL_FAST"

pipeline_failure_policy = DummyPipelineFailurePolicy
from aiplatform.utils.pipeline_utils import PipelineRuntimeConfigBuilder

# unit tests

# ----------- BASIC TEST CASES ------------

def test_basic_parameter_values():
    """Test basic scenario with parameterValues present and simple types."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://my-bucket/pipeline-root",
            "parameterValues": {
                "param1": 42,
                "param2": "hello",
                "param3": 3.14,
            },
            "failurePolicy": pipeline_failure_policy.PIPELINE_FAILURE_POLICY_FAIL_SLOW,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "param1": {"parameterType": "INT"},
                        "param2": {"parameterType": "STRING"},
                        "param3": {"parameterType": "DOUBLE"},
                    }
                }
            },
            "schemaVersion": "2.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 8.28μs -> 3.40μs (143% faster)

def test_basic_parameters_deprecated():
    """Test basic scenario with deprecated 'parameters' field."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/root",
            "parameters": {
                "foo": {"intValue": 7},
                "bar": {"stringValue": "baz"},
                "qux": {"doubleValue": 2.71},
            },
            "failurePolicy": pipeline_failure_policy.PIPELINE_FAILURE_POLICY_FAIL_FAST,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "foo": {"type": "INT"},
                        "bar": {"type": "STRING"},
                        "qux": {"type": "DOUBLE"},
                    }
                }
            },
            "schemaVersion": "1.5.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 8.85μs -> 4.32μs (105% faster)

def test_no_parameters():
    """Test scenario with no parameters defined."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/no-params",
            "failurePolicy": None,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {}
                }
            },
            "schemaVersion": "2.1.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 5.61μs -> 2.57μs (119% faster)

# ----------- EDGE TEST CASES ------------

def test_parameter_type_fallback():
    """Test fallback from parameterType to type."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/fallback",
            "parameterValues": {"p": 5},
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "p": {"type": "INT"}
                    }
                }
            },
            "schemaVersion": "2.0.1",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 6.55μs -> 2.88μs (127% faster)

def test_empty_job_spec():
    """Test empty job_spec raises KeyError."""
    with pytest.raises(KeyError):
        PipelineRuntimeConfigBuilder.from_job_spec_json({}) # 713ns -> 747ns (4.55% slower)

def test_missing_runtime_config():
    """Test missing runtimeConfig raises KeyError."""
    job_spec = {
        "pipelineSpec": {
            "root": {"inputDefinitions": {"parameters": {}}},
            "schemaVersion": "1.0.0",
        }
    }
    with pytest.raises(KeyError):
        PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec) # 661ns -> 678ns (2.51% slower)

def test_unknown_parameter_type_in_parameters():
    """Test unknown type in deprecated 'parameters' raises TypeError."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/unknown",
            "parameters": {
                "foo": {"unknownValue": "???"},
            }
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "foo": {"type": "STRING"},
                    }
                }
            },
            "schemaVersion": "1.0.0",
        }
    }
    with pytest.raises(TypeError) as excinfo:
        PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec) # 4.98μs -> 5.00μs (0.380% slower)

def test_missing_gcs_output_directory():
    """Test missing gcsOutputDirectory results in None pipeline_root."""
    job_spec = {
        "runtimeConfig": {
            "parameterValues": {"x": 1},
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "x": {"parameterType": "INT"},
                    }
                }
            },
            "schemaVersion": "2.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 7.50μs -> 3.16μs (137% faster)

def test_parameter_values_overrides_parameters():
    """Test that parameterValues takes precedence over parameters."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/override",
            "parameterValues": {"x": "from_values"},
            "parameters": {"x": {"stringValue": "from_parameters"}},
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "x": {"parameterType": "STRING"},
                    }
                }
            },
            "schemaVersion": "2.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 7.07μs -> 2.91μs (143% faster)

def test_parameter_values_none_and_parameters_none():
    """Test both parameterValues and parameters are None."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/none",
            "parameterValues": None,
            "parameters": None,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {}
                }
            },
            "schemaVersion": "2.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 5.79μs -> 2.62μs (121% faster)

def test_nonstandard_parameter_types():
    """Test nonstandard parameter types (should still be accepted)."""
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/nonstandard",
            "parameterValues": {"foo": "bar"},
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": {
                        "foo": {"parameterType": "CUSTOM_TYPE"},
                    }
                }
            },
            "schemaVersion": "2.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 6.75μs -> 2.81μs (140% faster)

# ----------- LARGE SCALE TEST CASES ------------

def test_large_number_of_parameters():
    """Test with a large number of parameters (up to 1000)."""
    n = 1000
    params = {f"p{i}": {"parameterType": "INT"} for i in range(n)}
    values = {f"p{i}": i for i in range(n)}
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large",
            "parameterValues": values,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": params
                }
            },
            "schemaVersion": "3.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 389μs -> 62.2μs (526% faster)

def test_large_parameters_deprecated():
    """Test with a large number of deprecated 'parameters'."""
    n = 1000
    params = {f"k{i}": {"type": "STRING"} for i in range(n)}
    values = {f"k{i}": {"stringValue": str(i)} for i in range(n)}
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large-deprecated",
            "parameters": values,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": params
                }
            },
            "schemaVersion": "1.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 482μs -> 147μs (226% faster)

def test_large_mixed_types():
    """Test with a large number of mixed parameter types."""
    n = 333  # 333 INT, 333 STRING, 334 DOUBLE = 1000 total
    params = {}
    values = {}
    for i in range(n):
        params[f"int_{i}"] = {"parameterType": "INT"}
        values[f"int_{i}"] = i
        params[f"str_{i}"] = {"parameterType": "STRING"}
        values[f"str_{i}"] = str(i)
    for i in range(n + 1):
        params[f"double_{i}"] = {"parameterType": "DOUBLE"}
        values[f"double_{i}"] = float(i) / 10
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large-mixed",
            "parameterValues": values,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": params
                }
            },
            "schemaVersion": "4.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 393μs -> 62.8μs (526% faster)

def test_large_missing_some_values():
    """Test when some parameters are missing values."""
    n = 500
    params = {f"p{i}": {"parameterType": "INT"} for i in range(n)}
    values = {f"p{i}": i for i in range(0, n, 2)}  # only even indices provided
    job_spec = {
        "runtimeConfig": {
            "gcsOutputDirectory": "gs://bucket/large-missing",
            "parameterValues": values,
        },
        "pipelineSpec": {
            "root": {
                "inputDefinitions": {
                    "parameters": params
                }
            },
            "schemaVersion": "5.0.0",
        }
    }
    codeflash_output = PipelineRuntimeConfigBuilder.from_job_spec_json(job_spec); builder = codeflash_output # 117μs -> 31.7μs (270% faster)
    for i in range(0, n, 2):
        pass
    for i in range(1, n, 2):
        pass
# 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.from_job_spec_json-mgijvwnb and push.