⚡️ Speed up function `maybe_filter_request_body` by 182% by codeflash-ai[bot] · Pull Request #10 · aseembits93/deepgram-python-sdk

codeflash-ai · 2025-10-17T07:43:09Z

📄 182% (1.82x) speedup for `maybe_filter_request_body` in `src/deepgram/core/http_client.py`

⏱️ Runtime : 28.5 milliseconds → 10.1 milliseconds (best of 101 runs)

📝 Explanation and details

Impact: high
Impact_explanation: Looking at this optimization report, I need to assess the impact based on the provided rubric and data.

Analysis of Key Metrics:

Overall Runtime Details:
- Original: 28.5ms → Optimized: 10.1ms
- Speedup: 181.68% (very significant)
- This is well above the 100 microseconds threshold and 15% speedup threshold
Generated Tests Performance:
- Consistently shows substantial speedups across test cases
- Most tests show 30-80% improvements
- Large-scale tests show 200-300% speedups
- Only a few edge cases show minor slowdowns (2-8%), but these are vastly outweighed by the gains
- The pattern shows consistent improvement, not just a few outlier fast cases
Replay Tests:
- Show 29-31% speedups on meaningful test cases
- One test shows minimal change (-0.761%), but others show consistent improvements
- The speedups are above the 5% threshold for high impact
Code Quality and Optimizations:
- The optimizations are algorithmic improvements (early fast-path, single-pass operations)
- Eliminates redundant operations and reduces object creation
- Uses more efficient Python constructs (dict/list comprehensions)
Hot Path Analysis:
- The calling_fn_details shows this function is called from get_request_body, which appears to be a core HTTP request processing function
- This suggests it's likely in a hot path for HTTP operations

Assessment:
The optimization shows:

Very significant overall speedup (181%)
Consistent improvements across most test cases
Replay tests showing meaningful speedups (29-31%)
Algorithmic improvements that should scale well
Function appears to be in HTTP request processing hot path

All indicators point to this being a high-impact optimization that provides substantial and consistent performance improvements.

END OF IMPACT EXPLANATION

The optimized code achieves a 181% speedup through several key optimizations:

1. Early Fast-Path for Common Types

Moved isinstance(obj, (str, int, float, type(None))) check to the very beginning of jsonable_encoder
This eliminates expensive checks (pydantic, dataclass) for 92% of objects in the profiler results
Line profiler shows this optimization alone saves significant time by avoiding 77M+ unnecessary dataclass checks

2. Efficient Dictionary Processing

Replaced the inefficient allowed_keys = set(obj.keys()) pattern with direct dictionary comprehension
Original code: created a set, looped through items, checked membership, then built result dict
Optimized code: single-pass dictionary comprehension that directly maps keys/values
This eliminates the redundant if key in allowed_keys check since we're iterating over the dict's own items

3. Single-Pass Dictionary Filtering

In remove_omit_from_dict, replaced the explicit loop with a dictionary comprehension
Original: 3-pass operation (initialize empty dict, loop with condition, assign)
Optimized: single-pass filtering {key: value for key, value in items() if value is not omit}
Profile shows 14x speedup (5.4ms → 0.38ms) for this function

4. List Comprehension Optimization

Replaced explicit encoded_list.append() loops with list comprehensions
This leverages C-level optimizations in Python's list comprehension implementation

5. Reduced Object Creation

Added .copy() to Pydantic encoder dictionaries to avoid mutating the original
Restructured maybe_filter_request_body to minimize intermediate object creation

These optimizations are particularly effective for the test cases involving large dictionaries and nested structures (200-300% speedups), where the elimination of redundant operations and single-pass processing compound significantly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import datetime as dt
from enum import Enum
from pathlib import PurePath

# imports
import pytest
from src.deepgram.core.http_client import maybe_filter_request_body

# --- Function under test and dependencies ---

# Minimal pydantic mock for testing
class DummyBaseModel:
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)
    def dict(self, by_alias=True):
        return self.__dict__
    __config__ = type("Config", (), {"json_encoders": {}})
    model_config = type("Config", (), {"json_encoders": {}})
from src.deepgram.core.http_client import maybe_filter_request_body

# --- Unit Tests ---

# Helper for request_options
def make_request_options(additional=None):
    return {"additional_body_parameters": additional or {}}

# 1. Basic Test Cases

def test_none_data_and_none_request_options_returns_none():
    # Both data and request_options are None
    codeflash_output = maybe_filter_request_body(None, None, None) # 569ns -> 607ns (6.26% slower)

def test_none_data_and_request_options_with_additional_params():
    # data is None, request_options has additional_body_parameters
    opts = make_request_options({"foo": "bar", "baz": 123})
    codeflash_output = maybe_filter_request_body(None, opts, None); result = codeflash_output # 13.0μs -> 7.58μs (71.3% faster)

def test_dict_data_no_omit_no_request_options():
    # data is dict, omit is None, request_options is None
    data = {"a": 1, "b": 2}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 15.4μs -> 10.4μs (47.9% faster)

def test_dict_data_with_omit_value():
    # data is dict, omit is present, request_options is None
    data = {"a": 1, "b": None, "c": 3}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 17.2μs -> 10.9μs (58.1% faster)
    # Now omit None
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 10.1μs -> 5.72μs (76.3% faster)
    # Now omit 3
    codeflash_output = maybe_filter_request_body(data, None, 3); result = codeflash_output # 8.09μs -> 4.99μs (62.3% faster)

def test_dict_data_with_request_options_merges():
    # data is dict, request_options has additional_body_parameters
    data = {"x": 5}
    opts = make_request_options({"y": 6, "z": 7})
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 20.1μs -> 13.4μs (50.1% faster)

def test_non_dict_data_is_json_encoded():
    # data is a list, should be jsonable_encoded
    data = [1, 2, 3]
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 12.3μs -> 8.93μs (37.2% faster)
    # data is a string
    data = "hello"
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 3.11μs -> 2.09μs (48.8% faster)
    # data is an int
    data = 42
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 2.35μs -> 1.41μs (66.1% faster)

def test_non_dict_data_with_request_options():
    # data is a list, request_options with additional_body_parameters
    data = [1, 2]
    opts = make_request_options({"foo": "bar"})
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 11.4μs -> 8.40μs (35.9% faster)

# 2. Edge Test Cases

def test_empty_dict_data_and_empty_additional_body_parameters():
    data = {}
    opts = make_request_options({})
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 11.7μs -> 10.4μs (12.2% faster)

def test_data_with_all_omit_values():
    data = {"a": None, "b": None}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 15.8μs -> 10.4μs (52.5% faster)
    # Omit None
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 8.63μs -> 5.36μs (61.0% faster)
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 7.20μs -> 4.17μs (72.4% faster)


def test_data_is_pydantic_model():
    # Simulate a pydantic model
    model = DummyBaseModel(a=1, b="x", c=None)
    codeflash_output = maybe_filter_request_body(model, None, None); result = codeflash_output # 63.9μs -> 55.8μs (14.6% faster)

def test_data_is_dataclass():
    import dataclasses
    @dataclasses.dataclass
    class Foo:
        x: int
        y: str
    instance = Foo(7, "bar")
    codeflash_output = maybe_filter_request_body(instance, None, None); result = codeflash_output # 79.7μs -> 87.4μs (8.82% slower)


def test_data_is_tuple_and_set():
    tup = (1, 2, 3)
    st = {4, 5, 6}
    codeflash_output = maybe_filter_request_body(tup, None, None); result = codeflash_output # 12.6μs -> 9.17μs (37.2% faster)
    codeflash_output = maybe_filter_request_body(st, None, None); result = codeflash_output # 7.14μs -> 4.84μs (47.5% faster)

def test_request_options_is_none_and_data_is_dict():
    data = {"foo": "bar"}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 13.2μs -> 9.63μs (37.0% faster)

def test_request_options_is_none_and_data_is_non_dict():
    data = "baz"
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 6.58μs -> 3.95μs (66.6% faster)

def test_request_options_additional_body_parameters_is_none():
    data = {"a": 1}
    opts = {"additional_body_parameters": None}
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 14.9μs -> 10.5μs (41.8% faster)

def test_request_options_additional_body_parameters_is_empty_dict():
    data = {"a": 1}
    opts = {"additional_body_parameters": {}}
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 16.0μs -> 12.1μs (32.4% faster)

def test_request_options_additional_body_parameters_merges_and_overwrites():
    data = {"a": 1, "b": 2}
    opts = make_request_options({"b": "overwritten", "c": 3})
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 21.9μs -> 14.1μs (55.0% faster)


def test_data_with_nested_dict_and_omit():
    data = {"a": {"x": 1, "y": None}, "b": 2}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 21.4μs -> 13.6μs (56.9% faster)
    # Omit 2
    codeflash_output = maybe_filter_request_body(data, None, 2); result = codeflash_output # 11.7μs -> 7.27μs (60.8% faster)

# 3. Large Scale Test Cases

def test_large_dict_data_merges_with_large_additional_body_parameters():
    data = {f"key{i}": i for i in range(500)}
    additional = {f"extra{i}": f"val{i}" for i in range(500)}
    opts = make_request_options(additional)
    codeflash_output = maybe_filter_request_body(data, opts, None); result = codeflash_output # 1.83ms -> 497μs (268% faster)
    # Should contain all keys from data and additional
    for i in range(500):
        pass

def test_large_list_data_is_jsonable_encoded():
    data = list(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 820μs -> 223μs (267% faster)

def test_large_nested_dict_and_omit():
    data = {f"k{i}": None if i % 2 == 0 else i for i in range(1000)}
    # Omit None
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 1.84ms -> 518μs (256% faster)
    for i in range(1000):
        pass
    # Omit value None
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 1.82ms -> 511μs (256% faster)
    for i in range(1000):
        pass
    # Omit value 500
    codeflash_output = maybe_filter_request_body(data, None, 500); result = codeflash_output # 1.90ms -> 582μs (226% faster)



#------------------------------------------------
import dataclasses
import datetime as dt
from enum import Enum
from pathlib import PurePath
from types import GeneratorType

import pydantic
# imports
import pytest
from src.deepgram.core.http_client import maybe_filter_request_body


# Minimal stubs required for the function to run
class RequestOptions(dict):
    pass
from src.deepgram.core.http_client import maybe_filter_request_body

# Basic Test Cases

def test_none_data_and_none_request_options_returns_none():
    # If both data and request_options are None, should return None
    codeflash_output = maybe_filter_request_body(None, None, None) # 599ns -> 612ns (2.12% slower)

def test_none_data_and_empty_request_options_returns_empty_dict():
    # If data is None and request_options has no additional_body_parameters
    codeflash_output = maybe_filter_request_body(None, RequestOptions(), None) # 7.47μs -> 6.50μs (15.0% faster)

def test_none_data_and_request_options_with_additional_body_parameters():
    # Should return encoded additional_body_parameters
    opts = RequestOptions()
    opts["additional_body_parameters"] = {"foo": "bar", "baz": 123}
    codeflash_output = maybe_filter_request_body(None, opts, None) # 13.1μs -> 7.80μs (67.8% faster)

def test_non_mapping_data_is_encoded():
    # If data is not a dict, should be encoded as-is
    codeflash_output = maybe_filter_request_body([1, 2, 3], None, None) # 12.6μs -> 9.13μs (37.8% faster)
    codeflash_output = maybe_filter_request_body("hello", None, None) # 2.93μs -> 2.10μs (39.9% faster)
    codeflash_output = maybe_filter_request_body(42, None, None) # 2.33μs -> 1.48μs (58.1% faster)

def test_mapping_data_no_omit_no_request_options():
    # Should just encode the dict as-is
    d = {"a": 1, "b": 2}
    codeflash_output = maybe_filter_request_body(d, None, None) # 15.5μs -> 10.5μs (47.7% faster)

def test_mapping_data_with_omit():
    # Should remove any values equal to omit
    d = {"a": 1, "b": None, "c": 3}
    codeflash_output = maybe_filter_request_body(d, None, None); result = codeflash_output # 17.3μs -> 10.9μs (58.6% faster)
    codeflash_output = maybe_filter_request_body(d, None, None); result2 = codeflash_output # 10.2μs -> 5.75μs (77.9% faster)
    codeflash_output = maybe_filter_request_body(d, None, 3); result3 = codeflash_output # 8.18μs -> 4.90μs (66.8% faster)

def test_mapping_data_with_request_options_merges_additional_body_parameters():
    d = {"x": 1}
    opts = RequestOptions()
    opts["additional_body_parameters"] = {"y": 2, "z": 3}
    codeflash_output = maybe_filter_request_body(d, opts, None); result = codeflash_output # 20.7μs -> 13.5μs (53.1% faster)

def test_mapping_data_with_omit_and_request_options():
    d = {"x": 1, "y": None}
    opts = RequestOptions()
    opts["additional_body_parameters"] = {"z": 3}
    codeflash_output = maybe_filter_request_body(d, opts, None); result = codeflash_output # 20.4μs -> 13.5μs (51.4% faster)
    codeflash_output = maybe_filter_request_body(d, opts, None); result2 = codeflash_output # 11.6μs -> 6.90μs (68.6% faster)
    codeflash_output = maybe_filter_request_body(d, opts, 1); result3 = codeflash_output # 9.38μs -> 6.07μs (54.6% faster)

def test_mapping_data_with_overlapping_keys_merges_and_overwrites():
    d = {"foo": "bar"}
    opts = RequestOptions()
    opts["additional_body_parameters"] = {"foo": "baz", "extra": "yes"}
    codeflash_output = maybe_filter_request_body(d, opts, None); result = codeflash_output # 20.1μs -> 13.1μs (52.8% faster)

# Edge Test Cases

def test_empty_dict_data_and_none_request_options():
    # Should return empty dict
    codeflash_output = maybe_filter_request_body({}, None, None) # 9.04μs -> 8.10μs (11.6% faster)

def test_empty_dict_data_and_request_options_with_empty_additional_body_parameters():
    opts = RequestOptions()
    opts["additional_body_parameters"] = {}
    codeflash_output = maybe_filter_request_body({}, opts, None) # 12.3μs -> 10.7μs (14.9% faster)

def test_data_with_all_values_omit():
    d = {"a": None, "b": None}
    codeflash_output = maybe_filter_request_body(d, None, None); result = codeflash_output # 15.9μs -> 10.8μs (47.6% faster)
    codeflash_output = maybe_filter_request_body(d, None, None); result2 = codeflash_output # 8.61μs -> 5.37μs (60.3% faster)
    codeflash_output = maybe_filter_request_body(d, None, None); result3 = codeflash_output # 7.03μs -> 4.26μs (65.2% faster)
    codeflash_output = maybe_filter_request_body(d, None, None); result4 = codeflash_output # 6.68μs -> 3.88μs (72.2% faster)
    codeflash_output = maybe_filter_request_body(d, None, None); result5 = codeflash_output # 6.38μs -> 3.65μs (75.0% faster)

def test_data_with_nonstring_keys():
    d = {1: "one", 2: "two"}
    codeflash_output = maybe_filter_request_body(d, None, None) # 15.6μs -> 10.5μs (49.3% faster)

def test_data_with_nested_dicts_and_omit():
    d = {"a": {"b": 2, "c": 3}, "d": 4}
    codeflash_output = maybe_filter_request_body(d, None, 4); result = codeflash_output # 19.6μs -> 13.2μs (48.1% faster)




def test_data_with_custom_encoder():
    def encode_int(x):
        return str(x)
    custom_encoder = {int: encode_int}

# Large Scale Test Cases

def test_large_flat_dict():
    # Large dict, no omit, no request_options
    d = {str(i): i for i in range(1000)}
    codeflash_output = maybe_filter_request_body(d, None, None); result = codeflash_output # 1.82ms -> 484μs (276% faster)

def test_large_flat_dict_with_omit():
    # Large dict, omit even numbers
    d = {str(i): i for i in range(1000)}
    codeflash_output = maybe_filter_request_body(d, None, 0); result = codeflash_output # 1.90ms -> 559μs (240% faster)
    # Now omit 42
    codeflash_output = maybe_filter_request_body(d, None, 42); result2 = codeflash_output # 1.87ms -> 548μs (240% faster)

def test_large_flat_dict_with_request_options():
    d = {str(i): i for i in range(900)}
    opts = RequestOptions()
    opts["additional_body_parameters"] = {str(i): i for i in range(900, 1000)}
    codeflash_output = maybe_filter_request_body(d, opts, None); result = codeflash_output # 1.84ms -> 498μs (269% faster)
    expected = {str(i): i for i in range(1000)}

def test_large_list_data():
    data = list(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 829μs -> 223μs (272% faster)

def test_large_nested_dict():
    # Dict with 100 keys, each value is a dict of 10 keys
    d = {str(i): {str(j): j for j in range(10)} for i in range(100)}
    codeflash_output = maybe_filter_request_body(d, None, None); result = codeflash_output # 2.01ms -> 624μs (222% faster)

def test_large_dict_with_large_request_options():
    d = {str(i): i for i in range(500)}
    opts = RequestOptions()
    opts["additional_body_parameters"] = {str(i): i for i in range(500, 1000)}
    codeflash_output = maybe_filter_request_body(d, opts, None); result = codeflash_output # 1.84ms -> 515μs (257% faster)
    expected = {str(i): i for i in range(1000)}

def test_large_set_data():
    data = set(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 845μs -> 229μs (268% faster)

def test_large_tuple_data():
    data = tuple(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 832μs -> 220μs (277% faster)


#------------------------------------------------
from src.deepgram.core.http_client import maybe_filter_request_body

def test_maybe_filter_request_body():
    maybe_filter_request_body(None, {}, '')

def test_maybe_filter_request_body_2():
    maybe_filter_request_body('', None, 0)

def test_maybe_filter_request_body_3():
    maybe_filter_request_body(None, None, '')

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
`test_pytest_testsintegrationstest_self_hosted_client_py_testscustomtest_client_py_testsunittest_core_json__replay_test_0.py::test_src_deepgram_core_http_client_maybe_filter_request_body`	56.1μs	42.8μs	31.0%✅
`test_pytest_testsunittest_agent_v1_models_py_testsintegrationstest_advanced_features_py_testsutilstest_se__replay_test_0.py::test_src_deepgram_core_http_client_maybe_filter_request_body`	3.00μs	3.02μs	-0.761%⚠️
`test_pytest_testsunittest_http_internals_py_testsintegrationstest_agent_client_py_testsunittest_telemetry__replay_test_0.py::test_src_deepgram_core_http_client_maybe_filter_request_body`	66.6μs	51.4μs	29.6%✅
`test_pytest_testsunittest_listen_v1_models_py_testsunittest_telemetry_models_py_testsintegrationstest_rea__replay_test_0.py::test_src_deepgram_core_http_client_maybe_filter_request_body`	1.44μs	1.42μs	1.27%✅

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
`codeflash_concolic_5p92pe1r/tmpt6ubvlqr/test_concolic_coverage.py::test_maybe_filter_request_body`	7.12μs	6.13μs	16.1%✅
`codeflash_concolic_5p92pe1r/tmpt6ubvlqr/test_concolic_coverage.py::test_maybe_filter_request_body_2`	7.16μs	4.38μs	63.6%✅
`codeflash_concolic_5p92pe1r/tmpt6ubvlqr/test_concolic_coverage.py::test_maybe_filter_request_body_3`	587ns	622ns	-5.63%⚠️

To edit these changes git checkout codeflash/optimize-maybe_filter_request_body-mgujkj48 and push.

Impact: high Impact_explanation: Looking at this optimization report, I need to assess the impact based on the provided rubric and data. **Analysis of Key Metrics:** 1. **Overall Runtime Details:** - Original: 28.5ms → Optimized: 10.1ms - Speedup: 181.68% (very significant) - This is well above the 100 microseconds threshold and 15% speedup threshold 2. **Generated Tests Performance:** - Consistently shows substantial speedups across test cases - Most tests show 30-80% improvements - Large-scale tests show 200-300% speedups - Only a few edge cases show minor slowdowns (2-8%), but these are vastly outweighed by the gains - The pattern shows consistent improvement, not just a few outlier fast cases 3. **Replay Tests:** - Show 29-31% speedups on meaningful test cases - One test shows minimal change (-0.761%), but others show consistent improvements - The speedups are above the 5% threshold for high impact 4. **Code Quality and Optimizations:** - The optimizations are algorithmic improvements (early fast-path, single-pass operations) - Eliminates redundant operations and reduces object creation - Uses more efficient Python constructs (dict/list comprehensions) 5. **Hot Path Analysis:** - The `calling_fn_details` shows this function is called from `get_request_body`, which appears to be a core HTTP request processing function - This suggests it's likely in a hot path for HTTP operations **Assessment:** The optimization shows: - Very significant overall speedup (181%) - Consistent improvements across most test cases - Replay tests showing meaningful speedups (29-31%) - Algorithmic improvements that should scale well - Function appears to be in HTTP request processing hot path All indicators point to this being a high-impact optimization that provides substantial and consistent performance improvements. END OF IMPACT EXPLANATION The optimized code achieves a **181% speedup** through several key optimizations: **1. Early Fast-Path for Common Types** - Moved `isinstance(obj, (str, int, float, type(None)))` check to the very beginning of `jsonable_encoder` - This eliminates expensive checks (pydantic, dataclass) for 92% of objects in the profiler results - Line profiler shows this optimization alone saves significant time by avoiding 77M+ unnecessary dataclass checks **2. Efficient Dictionary Processing** - Replaced the inefficient `allowed_keys = set(obj.keys())` pattern with direct dictionary comprehension - Original code: created a set, looped through items, checked membership, then built result dict - Optimized code: single-pass dictionary comprehension that directly maps keys/values - This eliminates the redundant `if key in allowed_keys` check since we're iterating over the dict's own items **3. Single-Pass Dictionary Filtering** - In `remove_omit_from_dict`, replaced the explicit loop with a dictionary comprehension - Original: 3-pass operation (initialize empty dict, loop with condition, assign) - Optimized: single-pass filtering `{key: value for key, value in items() if value is not omit}` - Profile shows 14x speedup (5.4ms → 0.38ms) for this function **4. List Comprehension Optimization** - Replaced explicit `encoded_list.append()` loops with list comprehensions - This leverages C-level optimizations in Python's list comprehension implementation **5. Reduced Object Creation** - Added `.copy()` to Pydantic encoder dictionaries to avoid mutating the original - Restructured `maybe_filter_request_body` to minimize intermediate object creation These optimizations are particularly effective for the test cases involving large dictionaries and nested structures (200-300% speedups), where the elimination of redundant operations and single-pass processing compound significantly.

codeflash-ai bot requested a review from aseembits93 October 17, 2025 07:43

codeflash-ai bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label Oct 17, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

⚡️ Speed up function `maybe_filter_request_body` by 182%#10

⚡️ Speed up function `maybe_filter_request_body` by 182%#10
codeflash-ai[bot] wants to merge 1 commit intomainfrom
codeflash/optimize-maybe_filter_request_body-mgujkj48

codeflash-ai bot commented Oct 17, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

Conversation

codeflash-ai bot commented Oct 17, 2025

📄 182% (1.82x) speedup for maybe_filter_request_body in src/deepgram/core/http_client.py

📝 Explanation and details

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

📄 182% (1.82x) speedup for `maybe_filter_request_body` in `src/deepgram/core/http_client.py`