⚡️ Speed up function single_query_encoder by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for single_query_encoder in src/deepgram/core/query_encoder.py

⏱️ Runtime : 12.5 milliseconds → 11.2 milliseconds (best of 121 runs)

📝 Explanation and details

The optimized code achieves a 12% speedup through several key micro-optimizations that reduce redundant type checking operations:

Key Optimizations:

1. Cached Type Checks: In single_query_encoder(), the optimized version caches the results of isinstance() calls in variables (is_base_model, is_dict, value_is_base, value_is_dict) instead of performing the same checks multiple times. This eliminates redundant type checking overhead.

2. Method Reference Caching: For list processing, the optimized code caches method references (append = encoded_values.append, extend = encoded_values.extend) to avoid repeated attribute lookups during iteration.

3. Streamlined Conditional Logic: The nested if-elif structure is replaced with cleaner boolean logic using the cached type check results, reducing branching overhead.

Performance Impact:
The optimizations are most effective for workloads with large lists of dictionaries or BaseModel objects, where the redundant isinstance() calls and method lookups compound. The line profiler shows the biggest time savings in the list processing section where isinstance() calls were being performed twice per iteration in the original code.

Test Case Performance:

• Large list of dicts: Shows the best improvement (28-29% faster) - this is where the cached type checks provide maximum benefit
• Simple scalar operations: Slightly slower (4-27%) due to the overhead of additional variable assignments for small inputs
• Complex nested structures: Generally 1-8% improvement, showing consistent but modest gains

The optimization trades a small constant overhead for significant savings on repeated operations, making it highly effective for the target use case of processing structured data with many dictionary/BaseModel objects.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 23 Passed
🌀 Generated Regression Tests	✅ 52 Passed
⏪ Replay Tests	✅ 43 Passed
🔎 Concolic Coverage Tests	✅ 3 Passed
📊 Tests Coverage	100.0%

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_dict_value	2.42μs	2.55μs	-4.87%⚠️
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_list_of_dicts	4.85μs	4.97μs	-2.35%⚠️
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_list_of_pydantic_models	28.8μs	27.8μs	3.59%✅
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_list_of_simple_values	2.28μs	2.54μs	-10.4%⚠️
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_mixed_list	3.86μs	4.05μs	-4.72%⚠️
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_pydantic_model	20.8μs	19.5μs	6.64%✅
unit/test_core_query_encoder.py::TestSingleQueryEncoder.test_simple_value	1.23μs	1.42μs	-13.4%⚠️

🌀 Generated Regression Tests and Runtime

import pydantic  # used for BaseModel in the function
# imports
import pytest  # used for our unit tests
from deepgram.core.query_encoder import single_query_encoder

# unit tests

# Basic Test Cases

def test_basic_scalar():
    # Test with a simple scalar value
    codeflash_output = single_query_encoder("foo", "bar") # 1.02μs -> 1.07μs (4.93% slower)
    codeflash_output = single_query_encoder("num", 123) # 693ns -> 682ns (1.61% faster)
    codeflash_output = single_query_encoder("flag", True) # 503ns -> 689ns (27.0% slower)

def test_basic_dict_flat():
    # Test with a flat dict
    d = {"a": 1, "b": 2}
    expected = [("foo[a]", 1), ("foo[b]", 2)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 2.44μs -> 2.51μs (2.63% slower)

def test_basic_dict_nested():
    # Test with a nested dict
    d = {"a": {"b": 2, "c": 3}, "d": 4}
    expected = [("foo[a][b]", 2), ("foo[a][c]", 3), ("foo[d]", 4)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 3.12μs -> 3.08μs (1.23% faster)

def test_basic_list_scalars():
    # Test with a list of scalars
    lst = [1, 2, 3]
    expected = [("foo", 1), ("foo", 2), ("foo", 3)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 1.98μs -> 2.37μs (16.3% slower)

def test_basic_list_dicts():
    # Test with a list of dicts
    lst = [{"a": 1}, {"b": 2}]
    expected = [("foo[a]", 1), ("foo[b]", 2)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 4.23μs -> 4.37μs (3.27% slower)



def test_empty_dict():
    # Test with an empty dict
    codeflash_output = single_query_encoder("foo", {}) # 1.58μs -> 1.69μs (6.39% slower)

def test_empty_list():
    # Test with an empty list
    codeflash_output = single_query_encoder("foo", []) # 1.11μs -> 1.44μs (22.7% slower)

def test_none_value():
    # Test with None value
    codeflash_output = single_query_encoder("foo", None) # 1.09μs -> 1.15μs (4.80% slower)

def test_dict_with_none():
    # Dict with None value
    d = {"a": None, "b": 2}
    expected = [("foo[a]", None), ("foo[b]", 2)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 2.51μs -> 2.56μs (2.22% slower)

def test_list_with_none():
    # List with None value
    lst = [None, 2]
    expected = [("foo", None), ("foo", 2)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 1.89μs -> 2.29μs (17.2% slower)

def test_dict_with_list():
    # Dict containing a list of scalars
    d = {"a": [1, 2], "b": 3}
    expected = [("foo[a]", 1), ("foo[a]", 2), ("foo[b]", 3)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 2.72μs -> 2.84μs (4.19% slower)

def test_dict_with_list_of_dicts():
    # Dict containing a list of dicts
    d = {"a": [{"x": 1}, {"y": 2}], "b": 3}
    expected = [("foo[a][x]", 1), ("foo[a][y]", 2), ("foo[b]", 3)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 3.63μs -> 3.67μs (1.06% slower)

def test_list_of_lists():
    # List containing lists of scalars
    lst = [[1, 2], [3]]
    expected = [("foo", [1, 2]), ("foo", [3])]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 1.66μs -> 2.10μs (21.3% slower)


def test_dict_with_empty_list():
    # Dict containing an empty list
    d = {"a": [], "b": 1}
    expected = [("foo[b]", 1)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 2.56μs -> 2.56μs (0.000% faster)

def test_dict_with_empty_dict():
    # Dict containing an empty dict
    d = {"a": {}, "b": 1}
    expected = [("foo[b]", 1)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 2.99μs -> 2.71μs (10.4% faster)

def test_list_with_empty_dict():
    # List containing an empty dict
    lst = [{}, {"a": 1}]
    expected = [("foo[a]", 1)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 4.06μs -> 4.16μs (2.45% slower)

def test_list_with_empty_list():
    # List containing an empty list
    lst = [[], 1]
    expected = [("foo", []), ("foo", 1)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 1.81μs -> 2.12μs (14.3% slower)

def test_deeply_nested_dict():
    # Dict with deep nesting
    d = {"a": {"b": {"c": {"d": 5}}}}
    expected = [("foo[a][b][c][d]", 5)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 3.58μs -> 3.30μs (8.26% faster)

def test_deeply_nested_list_dict():
    # Dict with deep nesting and lists
    d = {"a": [{"b": [1, 2]}, {"c": [3]}]}
    expected = [
        ("foo[a][b]", 1), ("foo[a][b]", 2),
        ("foo[a][c]", 3)
    ]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 3.52μs -> 3.63μs (2.89% slower)


def test_large_flat_dict():
    # Large flat dict
    d = {f"key{i}": i for i in range(1000)}
    expected = [(f"foo[key{i}]", i) for i in range(1000)]
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 134μs -> 130μs (2.84% faster)

def test_large_nested_dict():
    # Large nested dict (depth 3, 10 elements at each level)
    d = {f"a{i}": {f"b{j}": {f"c{k}": k for k in range(2)} for j in range(2)} for i in range(2)}
    expected = []
    for i in range(2):
        for j in range(2):
            for k in range(2):
                expected.append((f"foo[a{i}][b{j}][c{k}]", k))
    codeflash_output = single_query_encoder("foo", d); result = codeflash_output # 6.48μs -> 6.33μs (2.45% faster)

def test_large_list_scalars():
    # Large list of scalars
    lst = list(range(1000))
    expected = [("foo", i) for i in range(1000)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 122μs -> 127μs (4.26% slower)

def test_large_list_dicts():
    # Large list of dicts
    lst = [{"x": i} for i in range(1000)]
    expected = [("foo[x]", i) for i in range(1000)]
    codeflash_output = single_query_encoder("foo", lst); result = codeflash_output # 674μs -> 524μs (28.6% faster)



#------------------------------------------------
from typing import Any, Dict, List, Tuple

import pydantic
# imports
import pytest  # used for our unit tests
from deepgram.core.query_encoder import single_query_encoder

# unit tests

# --- Basic Test Cases ---

def test_basic_scalar_string():
    # Should encode a simple string value
    codeflash_output = single_query_encoder("foo", "bar") # 1.12μs -> 1.20μs (6.61% slower)

def test_basic_scalar_int():
    # Should encode a simple integer value
    codeflash_output = single_query_encoder("num", 42) # 1.14μs -> 1.21μs (5.61% slower)

def test_basic_scalar_float():
    # Should encode a simple float value
    codeflash_output = single_query_encoder("pi", 3.14) # 1.09μs -> 1.15μs (5.55% slower)

def test_basic_list_of_scalars():
    # Should encode a list of scalars as repeated key-value pairs
    codeflash_output = single_query_encoder("tags", ["a", "b", "c"]) # 1.87μs -> 2.36μs (20.5% slower)

def test_basic_dict_flat():
    # Should flatten a flat dictionary
    d = {"a": 1, "b": 2}
    codeflash_output = sorted(single_query_encoder("data", d)) # 2.59μs -> 2.62μs (1.11% slower)

def test_basic_nested_dict():
    # Should flatten a nested dictionary
    d = {"a": {"b": 2, "c": 3}, "d": 4}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 3.20μs -> 3.39μs (5.55% slower)
    expected = [("root[a][b]", 2), ("root[a][c]", 3), ("root[d]", 4)]


def test_basic_list_of_dicts():
    # Should flatten a list of dicts
    lst = [{"a": 1}, {"b": 2}]
    codeflash_output = single_query_encoder("things", lst); output = codeflash_output # 4.86μs -> 4.85μs (0.206% faster)
    expected = [("things[a]", 1), ("things[b]", 2)]


def test_edge_empty_dict():
    # Should return empty list for empty dict
    codeflash_output = single_query_encoder("empty", {}) # 1.62μs -> 1.62μs (0.309% faster)

def test_edge_empty_list():
    # Should return empty list for empty list
    codeflash_output = single_query_encoder("empty", []) # 1.13μs -> 1.44μs (21.8% slower)


def test_edge_none_value():
    # Should encode None as a value
    codeflash_output = single_query_encoder("none", None) # 1.25μs -> 1.26μs (1.11% slower)

def test_edge_dict_with_none():
    # Should encode None in dict value
    d = {"a": None, "b": 2}
    codeflash_output = single_query_encoder("data", d); output = codeflash_output # 2.71μs -> 2.63μs (3.00% faster)
    expected = [("data[a]", None), ("data[b]", 2)]

def test_edge_list_with_none():
    # Should encode None in list value
    lst = [None, 1]
    codeflash_output = single_query_encoder("lst", lst); output = codeflash_output # 1.92μs -> 2.27μs (15.5% slower)
    expected = [("lst", None), ("lst", 1)]

def test_edge_list_of_empty_dicts():
    # Should ignore empty dicts in list
    lst = [{}, {}]
    codeflash_output = single_query_encoder("lst", lst) # 3.64μs -> 3.69μs (1.33% slower)


def test_edge_nested_empty_dicts():
    # Should ignore nested empty dicts
    d = {"a": {}, "b": 1}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 3.13μs -> 2.98μs (5.03% faster)
    expected = [("root[b]", 1)]

def test_edge_nested_empty_lists():
    # Should ignore nested empty lists
    d = {"a": [], "b": 1}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 2.35μs -> 2.43μs (3.45% slower)
    expected = [("root[b]", 1)]

def test_edge_dict_with_list_of_dicts():
    # Should flatten dict with list of dicts
    d = {"lst": [{"a": 1}, {"b": 2}], "x": 3}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 3.73μs -> 3.74μs (0.294% slower)
    expected = [("root[lst][a]", 1), ("root[lst][b]", 2), ("root[x]", 3)]

def test_edge_dict_with_list_of_scalars():
    # Should flatten dict with list of scalars
    d = {"lst": [1, 2], "x": 3}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 2.63μs -> 2.67μs (1.65% slower)
    expected = [("root[lst]", 1), ("root[lst]", 2), ("root[x]", 3)]

def test_edge_list_of_lists():
    # Should flatten list of lists of scalars
    lst = [[1, 2], [3]]
    codeflash_output = single_query_encoder("foo", lst); output = codeflash_output # 1.70μs -> 2.16μs (21.3% slower)
    expected = [("foo", [1, 2]), ("foo", [3])]

def test_edge_deeply_nested_dict():
    # Should flatten deeply nested dict
    d = {"a": {"b": {"c": {"d": 1}}}}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 3.47μs -> 3.69μs (5.88% slower)
    expected = [("root[a][b][c][d]", 1)]

def test_edge_deeply_nested_list_of_dicts():
    # Should flatten list of dicts with nested dicts
    lst = [{"a": {"b": 1}}, {"c": {"d": 2}}]
    codeflash_output = single_query_encoder("root", lst); output = codeflash_output # 4.98μs -> 5.17μs (3.67% slower)
    expected = [("root[a][b]", 1), ("root[c][d]", 2)]

def test_edge_dict_with_mixed_types():
    # Should flatten dict with mixed types
    d = {"a": 1, "b": [2, {"c": 3}], "d": {"e": 4}}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 3.74μs -> 3.78μs (1.14% slower)
    expected = [("root[a]", 1), ("root[b]", 2), ("root[b][c]", 3), ("root[d][e]", 4)]


def test_large_flat_dict():
    # Should handle large flat dicts
    d = {str(i): i for i in range(1000)}
    codeflash_output = single_query_encoder("big", d); output = codeflash_output # 131μs -> 135μs (2.59% slower)
    expected = [("big[" + str(i) + "]", i) for i in range(1000)]

def test_large_list_of_scalars():
    # Should handle large list of scalars
    lst = list(range(1000))
    codeflash_output = single_query_encoder("nums", lst); output = codeflash_output # 125μs -> 129μs (3.71% slower)
    expected = [("nums", i) for i in range(1000)]

def test_large_list_of_dicts():
    # Should handle large list of dicts
    lst = [{"x": i} for i in range(1000)]
    codeflash_output = single_query_encoder("lst", lst); output = codeflash_output # 662μs -> 512μs (29.3% faster)
    expected = [("lst[x]", i) for i in range(1000)]

def test_large_nested_dict():
    # Should handle large nested dicts (depth 2)
    d = {str(i): {"x": i} for i in range(100)}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 34.4μs -> 34.5μs (0.171% slower)
    expected = [("root[" + str(i) + "][x]", i) for i in range(100)]


def test_large_dict_with_lists():
    # Should handle dict with large lists
    d = {"a": list(range(500)), "b": list(range(500, 1000))}
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 69.7μs -> 69.4μs (0.500% faster)
    expected = [("root[a]", i) for i in range(500)] + [("root[b]", i) for i in range(500, 1000)]

def test_large_complex_structure():
    # Should handle complex large structure with dicts and lists
    d = {
        "a": [{"x": i} for i in range(500)],
        "b": [i for i in range(500, 1000)],
        "c": {"y": 42}
    }
    codeflash_output = single_query_encoder("root", d); output = codeflash_output # 162μs -> 163μs (0.851% slower)
    expected = [("root[a][x]", i) for i in range(500)] + \
               [("root[b]", i) for i in range(500, 1000)] + \
               [("root[c][y]", 42)]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from deepgram.core.query_encoder import single_query_encoder

def test_single_query_encoder():
    single_query_encoder('', {})

def test_single_query_encoder_2():
    single_query_encoder('', [])

def test_single_query_encoder_3():
    single_query_encoder('', '')

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_testsintegrationstest_integration_scenarios_py_testsunittest_core_utils_py_testsutilstest_htt__replay_test_0.py::test_deepgram_core_query_encoder_single_query_encoder	19.0μs	17.9μs	6.20%✅
test_pytest_testsintegrationstest_manage_client_py_testsunittest_core_query_encoder_py_testsunittest_type__replay_test_0.py::test_deepgram_core_query_encoder_single_query_encoder	76.3μs	73.0μs	4.50%✅

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_d0k9fm5y/tmph0olehyx/test_concolic_coverage.py::test_single_query_encoder	1.59μs	1.58μs	0.063%✅
codeflash_concolic_d0k9fm5y/tmph0olehyx/test_concolic_coverage.py::test_single_query_encoder_2	1.04μs	1.38μs	-24.3%⚠️
codeflash_concolic_d0k9fm5y/tmph0olehyx/test_concolic_coverage.py::test_single_query_encoder_3	1.01μs	1.04μs	-3.73%⚠️

To edit these changes git checkout codeflash/optimize-single_query_encoder-mh2r5cj0 and push.