⚡️ Speed up function resolve_ref by 37%

[codeflash-ai]

📄 37% (0.37x) speedup for resolve_ref in src/openai/lib/_pydantic.py

⏱️ Runtime : 290 microseconds → 212 microseconds (best of 136 runs)

📝 Explanation and details

The optimized code achieves a 36% speedup by eliminating function call overhead in a performance-critical loop. The key optimization is replacing the is_dict(value) function call with a direct isinstance(value, dict) check inside the tight loop that traverses the JSON reference path.

Key changes:

1. Inlined the dictionary check: Replaced assert is_dict(value) with assert isinstance(value, dict) in the loop, avoiding the overhead of calling is_dict() which internally calls _is_dict().
2. Updated is_dict() function: Changed from return _is_dict(obj) to return isinstance(obj, dict) for consistency, eliminating an extra layer of function indirection.

Why this optimization works:

• The profiler shows the assertion line consumed 72.8% of total runtime in the original code (2.61ms out of 3.58ms)
• Function calls in Python have significant overhead, especially in tight loops
• The resolve_ref function is called repeatedly with deeply nested JSON structures, making the loop performance critical
• Each path traversal requires multiple dictionary type checks, amplifying the impact of the optimization

Performance benefits by test case type:

• Deep nesting tests show the largest gains (64-95% faster) because they execute the loop many times
• Basic multi-level tests show moderate gains (15-25% faster) with typical nesting depths
• Error cases show smaller but consistent gains (3-12% faster) due to the improved is_dict implementation
• Single-level tests show minimal gains since they bypass the tight loop optimization

This optimization is particularly effective for JSON schema resolution and API response parsing where deep object traversal is common.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from openai.lib._pydantic import resolve_ref

# =========================
# Unit Tests for resolve_ref
# =========================

# --- Basic Test Cases ---

def test_basic_single_level():
    # Test resolving a single-level reference
    root = {"foo": {"bar": {}}}
    ref = "#/foo"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 1.98μs -> 1.61μs (22.8% faster)

def test_basic_two_levels():
    # Test resolving a two-level reference
    root = {"foo": {"bar": {"baz": {}}}}
    ref = "#/foo/bar"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.17μs -> 1.82μs (19.1% faster)

def test_basic_three_levels():
    # Test resolving a three-level reference
    root = {"a": {"b": {"c": {"d": {}}}}}
    ref = "#/a/b/c"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.09μs -> 1.74μs (20.6% faster)

def test_basic_empty_dict():
    # Test resolving to an empty dictionary
    root = {"foo": {}}
    ref = "#/foo"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 1.68μs -> 1.49μs (12.8% faster)

def test_basic_multiple_keys():
    # Test resolving with multiple keys at root
    root = {"foo": {"bar": {}}, "baz": {"qux": {}}}
    ref = "#/baz"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 1.71μs -> 1.47μs (16.4% faster)

# --- Edge Test Cases ---

def test_ref_not_starting_with_hash_slash():
    # Test that ValueError is raised for invalid ref format
    root = {"foo": {"bar": {}}}
    ref = "/foo/bar"
    with pytest.raises(ValueError):
        resolve_ref(root=root, ref=ref) # 1.59μs -> 1.64μs (3.35% slower)

def test_ref_empty_string():
    # Test that ValueError is raised for empty ref
    root = {"foo": {"bar": {}}}
    ref = ""
    with pytest.raises(ValueError):
        resolve_ref(root=root, ref=ref) # 1.53μs -> 1.57μs (2.04% slower)

def test_ref_only_hash_slash():
    # Test that resolve_ref returns root for ref="#/"
    root = {"foo": {"bar": {}}}
    ref = "#/"
    # The path is empty, so resolved = root, but the for loop is skipped
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output

def test_key_not_found():
    # Test KeyError when key is missing in path
    root = {"foo": {"bar": {}}}
    ref = "#/foo/baz"
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref=ref) # 3.12μs -> 2.57μs (21.2% faster)

def test_non_dict_encountered():
    # Test AssertionError when a non-dict is encountered
    root = {"foo": {"bar": 123}}
    ref = "#/foo/bar"
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref=ref) # 4.78μs -> 4.30μs (11.2% faster)

def test_root_is_not_dict():
    # Test that TypeError is raised if root is not a dict
    root = "not a dict"
    ref = "#/foo"
    with pytest.raises(TypeError):
        resolve_ref(root=root, ref=ref) # 1.89μs -> 1.89μs (0.475% slower)

def test_key_is_empty_string():
    # Test that empty keys are handled (should raise KeyError)
    root = {"": {"bar": {}}}
    ref = "#//bar"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.32μs -> 1.95μs (19.4% faster)

def test_key_is_none():
    # Test that None as a key is handled (should raise KeyError)
    root = {None: {"bar": {}}}
    ref = "#/None/bar"
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref=ref) # 1.93μs -> 1.88μs (2.82% faster)

def test_root_is_empty_dict():
    # Test that KeyError is raised if root is empty
    root = {}
    ref = "#/foo"
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref=ref) # 1.76μs -> 1.83μs (3.34% slower)

def test_path_with_numeric_keys():
    # Test that numeric keys (as strings) are handled
    root = {"1": {"2": {"3": {}}}}
    ref = "#/1/2/3"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.43μs -> 1.97μs (23.7% faster)

def test_path_with_special_characters():
    # Test that keys with special characters are handled
    root = {"foo/bar": {"baz-qux": {"!@#": {}}}}
    ref = "#/foo/bar/baz-qux/!@#"
    # This ref will split as ["foo", "bar", "baz-qux", "!@#"] which won't match keys
    # But let's test the correct scenario:
    root = {"foo": {"bar": {"baz-qux": {"!@#": {}}}}}
    ref = "#/foo/bar/baz-qux/!@#"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.62μs -> 2.28μs (15.0% faster)

def test_path_with_unicode_keys():
    # Test that unicode keys are handled
    root = {"你好": {"世界": {}}}
    ref = "#/你好/世界"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.96μs -> 2.76μs (7.43% faster)

def test_path_with_empty_segments():
    # Test that consecutive slashes produce empty segments
    root = {"foo": {"": {"bar": {}}}}
    ref = "#/foo//bar"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.39μs -> 2.02μs (18.1% faster)

# --- Large Scale Test Cases ---

def test_large_deeply_nested_dict():
    # Test resolving a reference in a deeply nested dictionary (depth=100)
    depth = 100
    root = current = {}
    for i in range(depth):
        new_dict = {}
        current[str(i)] = new_dict
        current = new_dict
    # ref is "#/0/1/2/.../99"
    ref = "#/" + "/".join(str(i) for i in range(depth))
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 15.7μs -> 9.23μs (70.2% faster)

def test_large_wide_dict():
    # Test resolving a reference in a wide dictionary (width=1000)
    width = 1000
    root = {str(i): {} for i in range(width)}
    # Pick a key to resolve
    key = str(width // 2)
    ref = f"#/{key}"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.31μs -> 1.87μs (23.5% faster)

def test_large_deep_and_wide_dict():
    # Test resolving a reference in a dict with both depth and width (depth=10, width=10)
    depth = 10
    width = 10
    root = {}
    current = root
    for i in range(depth):
        current[str(i)] = {str(j): {} for j in range(width)}
        current = current[str(i)]
    # ref is "#/0/1/2/3/4/5/6/7/8/9/5"
    ref = "#/" + "/".join(str(i) for i in range(depth)) + "/5"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 3.46μs -> 2.44μs (41.7% faster)

def test_large_missing_key():
    # Test resolving a missing key in a large dictionary
    root = {str(i): {} for i in range(1000)}
    ref = "#/notfound"
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref=ref) # 2.01μs -> 1.92μs (4.86% faster)

def test_large_non_dict_leaf():
    # Test resolving a path where the last value is not a dict in a large dict
    root = {"a": {"b": {"c": 123}}}
    ref = "#/a/b/c"
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref=ref) # 4.72μs -> 4.24μs (11.5% faster)

def test_large_path_with_empty_keys():
    # Test resolving a path with empty keys in a large dict
    root = {"": {"": {"": {}}}}
    ref = "#///"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output # 2.28μs -> 1.97μs (15.7% faster)

def test_large_ref_only_hash_slash():
    # Test that resolve_ref returns root for ref="#/" in a large dict
    root = {str(i): {} for i in range(1000)}
    ref = "#/"
    codeflash_output = resolve_ref(root=root, ref=ref); result = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from openai.lib._pydantic import resolve_ref

# unit tests

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

def test_basic_single_level_ref():
    # Test resolving a single-level reference
    root = {"foo": {"bar": {}}}
    codeflash_output = resolve_ref(root=root, ref="#/foo") # 1.90μs -> 1.73μs (9.72% faster)

def test_basic_multi_level_ref():
    # Test resolving a multi-level reference
    root = {"a": {"b": {"c": 123}}}
    codeflash_output = resolve_ref(root=root, ref="#/a/b") # 2.10μs -> 1.75μs (20.1% faster)

def test_basic_deep_ref():
    # Test resolving a deep reference
    root = {"x": {"y": {"z": {"w": 42}}}}
    codeflash_output = resolve_ref(root=root, ref="#/x/y/z") # 2.11μs -> 1.86μs (13.7% faster)

def test_basic_return_dict_reference():
    # Should return the dict at the referenced path
    root = {"foo": {"bar": {"baz": "qux"}}}
    codeflash_output = resolve_ref(root=root, ref="#/foo/bar"); result = codeflash_output # 2.19μs -> 1.91μs (14.7% faster)

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

def test_edge_invalid_ref_format():
    # Should raise ValueError if ref does not start with "#/"
    root = {"foo": {"bar": {}}}
    with pytest.raises(ValueError):
        resolve_ref(root=root, ref="foo/bar") # 1.57μs -> 1.58μs (0.759% slower)

def test_edge_empty_path():
    # Should raise KeyError if path is empty after "#/"
    root = {"foo": {"bar": {}}}
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref="#/") # 1.86μs -> 1.80μs (3.39% faster)

def test_edge_nonexistent_key():
    # Should raise KeyError if key does not exist
    root = {"foo": {"bar": {}}}
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref="#/foo/baz") # 2.50μs -> 2.24μs (11.8% faster)

def test_edge_non_dict_in_path():
    # Should raise AssertionError if a non-dict is encountered in the path
    root = {"foo": 123}
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref="#/foo/bar") # 4.21μs -> 3.94μs (6.85% faster)

def test_edge_root_is_not_dict():
    # Should raise TypeError if root is not a dict (since root[key] will fail)
    with pytest.raises(TypeError):
        resolve_ref(root="not_a_dict", ref="#/foo") # 1.97μs -> 1.88μs (4.69% faster)

def test_edge_key_is_empty_string():
    # Should raise KeyError if a path component is empty string and not present
    root = {"": {"bar": 1}}
    codeflash_output = resolve_ref(root=root, ref="#/") # 1.99μs -> 1.59μs (25.3% faster)



def test_edge_path_with_empty_dict():
    # Should resolve to an empty dict if that's the target
    root = {"foo": {"bar": {}}}
    codeflash_output = resolve_ref(root=root, ref="#/foo/bar") # 2.89μs -> 2.24μs (29.0% faster)

def test_edge_path_with_none_value():
    # Should raise AssertionError if a None is encountered in the path
    root = {"foo": None}
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref="#/foo/bar") # 4.25μs -> 3.93μs (8.14% faster)

def test_edge_path_with_list_value():
    # Should raise AssertionError if a list is encountered in the path
    root = {"foo": []}
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref="#/foo/bar") # 3.89μs -> 3.61μs (7.87% faster)

def test_edge_path_with_bool_value():
    # Should raise AssertionError if a bool is encountered in the path
    root = {"foo": True}
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref="#/foo/bar") # 3.93μs -> 3.49μs (12.7% faster)

def test_edge_path_with_empty_ref_string():
    # Should raise ValueError if ref is empty string
    root = {"foo": {"bar": {}}}
    with pytest.raises(ValueError):
        resolve_ref(root=root, ref="") # 1.59μs -> 1.61μs (1.24% slower)

def test_edge_path_with_only_hash():
    # Should raise ValueError if ref is just "#"
    root = {"foo": {"bar": {}}}
    with pytest.raises(ValueError):
        resolve_ref(root=root, ref="#") # 1.52μs -> 1.52μs (0.197% slower)

def test_edge_path_with_trailing_slash():
    # Should raise KeyError if trailing slash leads to empty key not present
    root = {"foo": {"bar": {}}}
    with pytest.raises(KeyError):
        resolve_ref(root=root, ref="#/foo/bar/") # 2.95μs -> 2.55μs (15.7% faster)

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

def test_large_scale_deep_nesting():
    # Test with deeply nested dictionaries (depth 100)
    depth = 100
    root = current = {}
    for i in range(depth):
        new_dict = {}
        current[str(i)] = new_dict
        current = new_dict
    # Build the reference
    ref_path = "#/" + "/".join(str(i) for i in range(depth))
    codeflash_output = resolve_ref(root=root, ref=ref_path) # 16.1μs -> 9.53μs (68.5% faster)

def test_large_scale_wide_dict():
    # Test with a wide dictionary (1000 top-level keys)
    root = {str(i): {"leaf": i} for i in range(1000)}
    # Pick a few random keys to test
    for i in [0, 499, 999]:
        ref = f"#/{i}"
        codeflash_output = resolve_ref(root=root, ref=ref) # 3.96μs -> 3.38μs (17.2% faster)

def test_large_scale_deep_and_wide():
    # Test with both deep and wide dictionaries
    # root["a"]["b"]["c"] ... ["z"] = {"leaf": "end"}
    import string
    keys = list(string.ascii_lowercase)
    root = current = {}
    for k in keys:
        new_dict = {}
        current[k] = new_dict
        current = new_dict
    current["leaf"] = "end"
    ref_path = "#/" + "/".join(keys)
    codeflash_output = resolve_ref(root=root, ref=ref_path) # 4.84μs -> 2.94μs (64.9% faster)

def test_large_scale_multiple_refs():
    # Test resolving multiple references in a large dict
    root = {str(i): {str(j): {"val": i * j} for j in range(10)} for i in range(10)}
    for i in range(10):
        for j in range(10):
            ref = f"#/{i}/{j}"
            codeflash_output = resolve_ref(root=root, ref=ref)

def test_large_scale_performance():
    # Test that function does not hang or error with large but valid input
    root = {}
    current = root
    for i in range(500):
        new_dict = {}
        current[str(i)] = new_dict
        current = new_dict
    ref_path = "#/" + "/".join(str(i) for i in range(500))
    codeflash_output = resolve_ref(root=root, ref=ref_path) # 67.4μs -> 34.6μs (94.8% faster)

# -------------------------
# Mutation Testing Guards
# -------------------------

def test_mutation_wrong_return():
    # If resolve_ref returns anything other than the correct dict, this test fails
    root = {"foo": {"bar": {"baz": "qux"}}}
    codeflash_output = resolve_ref(root=root, ref="#/foo/bar"); result = codeflash_output # 2.15μs -> 1.80μs (19.5% faster)

def test_mutation_wrong_path():
    # If resolve_ref does not follow the exact path, this test fails
    root = {"a": {"b": {"c": {"d": 1}}}}
    codeflash_output = resolve_ref(root=root, ref="#/a/b/c") # 2.03μs -> 1.62μs (25.1% faster)

def test_mutation_wrong_error():
    # If resolve_ref does not raise ValueError for non-#/ ref, this test fails
    root = {"foo": {"bar": {}}}
    with pytest.raises(ValueError):
        resolve_ref(root=root, ref="foo/bar") # 1.59μs -> 1.58μs (0.698% faster)

def test_mutation_wrong_assertion():
    # If resolve_ref does not assert on non-dict, this test fails
    root = {"foo": 123}
    with pytest.raises(AssertionError):
        resolve_ref(root=root, ref="#/foo/bar") # 4.15μs -> 4.01μs (3.41% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from openai.lib._pydantic import resolve_ref
import pytest

def test_resolve_ref():
    with pytest.raises(AssertionError, match="encountered\\ non\\-dictionary\\ entry\\ while\\ resolving\\ \\#//\x00\\ \\-\\ \\{'':\\ ''\\}"):
        resolve_ref(root={'': ''}, ref='#//\x00')

def test_resolve_ref_2():
    with pytest.raises(ValueError, match="Unexpected\\ \\$ref\\ format\\ '';\\ Does\\ not\\ start\\ with\\ \\#/"):
        resolve_ref(root={}, ref='')

def test_resolve_ref_3():
    resolve_ref(root={'': {}}, ref='#/')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_g6lys7gg/tmpdjf3t3a1/test_concolic_coverage.py::test_resolve_ref	4.78μs	4.29μs	11.5%✅
codeflash_concolic_g6lys7gg/tmpdjf3t3a1/test_concolic_coverage.py::test_resolve_ref_2	1.75μs	1.62μs	8.47%✅
codeflash_concolic_g6lys7gg/tmpdjf3t3a1/test_concolic_coverage.py::test_resolve_ref_3	1.98μs	1.59μs	24.3%✅

To edit these changes git checkout codeflash/optimize-resolve_ref-mhd4t13h and push.