⚡️ Speed up function maybe_filter_request_body by 126%

[codeflash-ai]

📄 126% (1.26x) speedup for maybe_filter_request_body in skyvern/client/core/http_client.py

⏱️ Runtime : 9.66 milliseconds → 4.27 milliseconds (best of 148 runs)

📝 Explanation and details

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

Primary Optimizations:

1. Early primitive type fast-path: Moved isinstance(obj, (str, int, float, type(None))) check to the very top of jsonable_encoder(). Since primitives are the most common case (21,152/23,525 hits), this eliminates unnecessary work for ~90% of calls.

2. Dict comprehension over manual loops:

   • In remove_omit_from_dict(): Replaced manual dict construction with {key: value for key, value in original.items() if value is not omit}, reducing bytecode operations by ~10x
   • In jsonable_encoder(): Used dict/list comprehensions for encoding collections, leveraging CPython's optimized comprehension implementation

3. Eliminated redundant operations:

   • Removed unnecessary allowed_keys = set(obj.keys()) allocation and lookup in dict encoding
   • Optimized custom encoder lookups using dict.get() instead of type(obj) in custom_encoder
   • Streamlined Pydantic model handling by avoiding redundant root key checks

4. Reduced function call overhead: Restructured maybe_filter_request_body() to minimize repeated jsonable_encoder() calls and dictionary operations.

Impact on Workloads:
Based on the function_references, this function is called from get_request_body() which processes HTTP request data. The optimizations are particularly beneficial for:

• Large dictionaries (309-346% speedup on 1000-item dicts)
• Collections with many primitives (296-298% speedup on large lists/tuples)
• Nested data structures common in API payloads

The test results show consistent 20-70% improvements on typical API data sizes, with dramatic gains on large datasets, making this optimization highly valuable for HTTP client performance in data-intensive applications.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

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

# Pydantic model for testing
import pydantic
# imports
import pytest
from skyvern.client.core.http_client import maybe_filter_request_body

# Import the function to test (assume it's in the same file for this test suite)
# If it were in a module, you'd do: from skyvern.client.core.http_client import maybe_filter_request_body

# Minimal stub for RequestOptions to mimic dict-like behavior
class RequestOptions(dict):
    pass

# Test Enums for testing
class Color(Enum):
    RED = "red"
    GREEN = "green"
    BLUE = "blue"

@dataclasses.dataclass
class Point:
    x: int
    y: int

class TestModel(pydantic.BaseModel):
    a: int
    b: str

# Helper to create a UTC datetime
def utc_dt(year, month, day, hour=0, minute=0, second=0):
    return dt.datetime(year, month, day, hour, minute, second, tzinfo=dt.timezone.utc)

# function to test (as provided above)
# ... (assume maybe_filter_request_body is defined above, as per your code block) ...

# ------------------- UNIT TESTS -------------------

# 1. BASIC TEST CASES

def test_none_data_and_none_request_options_returns_none():
    # Both data and request_options are None, should return None
    codeflash_output = maybe_filter_request_body(None, None, None) # 332ns -> 367ns (9.54% slower)

def test_none_data_with_additional_body_parameters():
    # data is None, request_options has additional_body_parameters
    ro = RequestOptions({"additional_body_parameters": {"foo": "bar"}})
    codeflash_output = maybe_filter_request_body(None, ro, None) # 5.13μs -> 3.42μs (49.8% faster)

def test_data_is_simple_dict_no_omit_no_additional():
    # Simple dict, no omit, no additional_body_parameters
    data = {"a": 1, "b": 2}
    codeflash_output = maybe_filter_request_body(data, None, None) # 7.37μs -> 5.47μs (34.7% faster)

def test_data_is_simple_dict_with_additional_body_parameters():
    # Dict with additional_body_parameters merged in
    data = {"a": 1}
    ro = RequestOptions({"additional_body_parameters": {"b": 2}})
    codeflash_output = maybe_filter_request_body(data, ro, None); result = codeflash_output # 7.88μs -> 6.32μs (24.7% faster)

def test_data_is_simple_dict_with_omit():
    # Dict with value to omit
    data = {"a": 1, "b": None}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 6.71μs -> 4.70μs (42.7% faster)
    # Now omit None
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 3.51μs -> 2.15μs (63.1% faster)
    # Omit value 1
    codeflash_output = maybe_filter_request_body(data, None, 1); result = codeflash_output # 2.86μs -> 2.10μs (36.2% faster)

def test_data_is_non_dict_type():
    # Data is a list
    data = [1, 2, 3]
    codeflash_output = maybe_filter_request_body(data, None, None) # 5.15μs -> 3.98μs (29.2% faster)
    # Data is a string
    data = "hello"
    codeflash_output = maybe_filter_request_body(data, None, None) # 1.71μs -> 1.16μs (46.7% faster)
    # Data is an int
    data = 42
    codeflash_output = maybe_filter_request_body(data, None, None) # 985ns -> 668ns (47.5% faster)

def test_data_is_bytes():
    # Data is bytes, should be base64 encoded
    data = b"abc"
    expected = "YWJj"
    codeflash_output = maybe_filter_request_body(data, None, None) # 3.71μs -> 4.09μs (9.25% slower)

def test_data_is_path():
    # Data is a PurePath
    data = PurePath("/tmp/test.txt")
    codeflash_output = maybe_filter_request_body(data, None, None) # 11.2μs -> 10.8μs (4.41% faster)

def test_data_is_datetime():
    # Data is a UTC datetime
    data = utc_dt(2020, 1, 1, 12, 0, 0)
    codeflash_output = maybe_filter_request_body(data, None, None) # 11.4μs -> 11.3μs (0.701% faster)

def test_data_is_date():
    # Data is a date
    data = dt.date(2020, 1, 1)
    codeflash_output = maybe_filter_request_body(data, None, None) # 5.17μs -> 5.12μs (0.879% faster)

def test_data_is_dataclass():
    # Data is a dataclass instance
    data = Point(1, 2)
    codeflash_output = maybe_filter_request_body(data, None, None) # 11.7μs -> 9.51μs (22.6% faster)

def test_data_is_dict_with_various_types():
    # Dict with mixed types
    data = {
        "int": 1,
        "str": "x",
        "enum": Color.GREEN,
        "bytes": b"hi",
        "path": PurePath("/a/b"),
        "dt": utc_dt(2023, 4, 5, 6, 7, 8),
        "date": dt.date(2023, 4, 5),
        "list": [1, 2],
        "tuple": (3, 4),
        "set": {5, 6},
        "frozenset": frozenset([7, 8]),
    }
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 39.5μs -> 32.7μs (20.7% faster)

# 2. EDGE TEST CASES

def test_empty_dict_and_none_omit():
    # Empty dict, no omit
    data = {}
    codeflash_output = maybe_filter_request_body(data, None, None) # 3.71μs -> 3.66μs (1.31% faster)

def test_empty_dict_with_additional_body_parameters():
    # Empty dict, additional_body_parameters present
    ro = RequestOptions({"additional_body_parameters": {"foo": "bar"}})
    codeflash_output = maybe_filter_request_body({}, ro, None) # 6.85μs -> 5.60μs (22.2% faster)

def test_dict_with_all_values_omitted():
    # All values in dict are the omit value
    data = {"a": None, "b": None}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 6.61μs -> 4.62μs (42.9% faster)
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 3.67μs -> 2.17μs (69.0% faster)
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 2.87μs -> 1.85μs (55.6% faster)
    # Omit None
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 2.66μs -> 1.56μs (70.4% faster)

def test_dict_with_some_values_omitted():
    # Some values are omitted
    data = {"a": 1, "b": None, "c": 2}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 7.07μs -> 4.47μs (57.9% faster)
    codeflash_output = maybe_filter_request_body(data, None, 2); result = codeflash_output # 4.15μs -> 2.79μs (48.8% faster)

def test_data_is_tuple():
    # Data is a tuple
    data = (1, 2, 3)
    codeflash_output = maybe_filter_request_body(data, None, None) # 6.00μs -> 4.71μs (27.4% faster)

def test_data_is_set():
    # Data is a set
    data = {4, 5, 6}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 5.54μs -> 4.42μs (25.3% faster)

def test_data_is_frozenset():
    # Data is a frozenset
    data = frozenset([7, 8, 9])
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 5.69μs -> 4.52μs (26.0% faster)

def test_data_is_nested_dict():
    # Dict with nested dicts and lists
    data = {"a": {"b": [1, 2, {"c": 3}]}}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 11.4μs -> 8.61μs (32.5% faster)

def test_data_is_deeply_nested():
    # Deeply nested structure
    data = {"a": [{"b": {"c": [1, 2, {"d": "e"}]}}]}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 12.2μs -> 9.03μs (35.1% faster)

def test_data_is_object_with_dict_and_vars():
    # Object with __dict__ and vars
    class Dummy:
        def __init__(self):
            self.x = 10
            self.y = 20
    data = Dummy()
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 63.2μs -> 58.1μs (8.84% faster)

def test_data_is_object_with_dict_method():
    # Object with dict() method
    class Dummy:
        def __init__(self):
            self.x = 1
        def __iter__(self):
            return iter([("x", self.x)])
        def __getitem__(self, key):
            if key == "x":
                return self.x
            raise KeyError(key)
        def __dict__(self):
            return {"x": self.x}
    data = Dummy()
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 43.9μs -> 51.6μs (14.9% slower)

def test_data_is_dict_with_root_key():
    # Dict with "__root__" key
    data = {"__root__": {"foo": "bar"}}
    codeflash_output = maybe_filter_request_body(data, None, None) # 9.88μs -> 8.08μs (22.3% faster)

def test_data_is_dict_with_root_and_other_keys():
    # Dict with "root" key
    data = {"root": {"foo": "bar"}}
    codeflash_output = maybe_filter_request_body(data, None, None) # 7.57μs -> 5.79μs (30.7% faster)

def test_data_is_dict_with_additional_body_parameters_and_omit():
    # Dict with additional_body_parameters and omit
    data = {"a": 1, "b": None}
    ro = RequestOptions({"additional_body_parameters": {"c": 3}})
    codeflash_output = maybe_filter_request_body(data, ro, None); result = codeflash_output # 9.21μs -> 6.52μs (41.1% faster)
    codeflash_output = maybe_filter_request_body(data, ro, 1); result = codeflash_output # 4.64μs -> 3.37μs (37.7% faster)

# 3. LARGE SCALE TEST CASES

def test_large_dict():
    # Large dict, 1000 items
    data = {str(i): i for i in range(1000)}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 704μs -> 172μs (309% faster)
    for i in range(1000):
        pass

def test_large_dict_with_omit():
    # Large dict, omit even numbers
    data = {str(i): i for i in range(1000)}
    codeflash_output = maybe_filter_request_body(data, None, 0); result = codeflash_output # 734μs -> 213μs (244% faster)

def test_large_list():
    # Large list, 1000 items
    data = list(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 311μs -> 78.6μs (296% faster)

def test_large_nested_dict():
    # Large dict with nested dicts/lists
    data = {str(i): {"nums": list(range(i, i+10))} for i in range(100)}
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 505μs -> 224μs (125% faster)
    for i in range(100):
        pass

def test_large_dict_with_additional_body_parameters():
    # Large dict with additional_body_parameters
    data = {str(i): i for i in range(900)}
    ro = RequestOptions({"additional_body_parameters": {str(i): i for i in range(900, 1000)}})
    codeflash_output = maybe_filter_request_body(data, ro, None); result = codeflash_output # 710μs -> 176μs (301% faster)
    for i in range(1000):
        pass

def test_large_set():
    # Large set, 1000 items
    data = set(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 311μs -> 80.9μs (286% faster)

def test_large_frozenset():
    # Large frozenset, 1000 items
    data = frozenset(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 311μs -> 79.7μs (290% faster)

def test_large_tuple():
    # Large tuple, 1000 items
    data = tuple(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 310μs -> 78.0μs (298% faster)

def test_large_dataclass_list():
    # List of dataclasses
    data = [Point(x, x+1) for x in range(1000)]
    codeflash_output = maybe_filter_request_body(data, None, None); result = codeflash_output # 2.95ms -> 1.88ms (57.1% faster)
    for idx, item in enumerate(result):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

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

import pydantic
# imports
import pytest
from skyvern.client.core.http_client import maybe_filter_request_body

# --- Begin: Minimal stubs and helpers for dependencies ---

# Minimal stub for RequestOptions (should behave like a dict)
class RequestOptions(dict):
    pass
from skyvern.client.core.http_client import maybe_filter_request_body

# --- End: Function and dependencies ---

# --- Begin: Unit Tests ---

# 1. Basic Test Cases

def test_none_data_and_none_request_options_returns_none():
    # If data is None and request_options is None, should return None.
    codeflash_output = maybe_filter_request_body(None, None, None) # 360ns -> 365ns (1.37% slower)

def test_none_data_with_request_options_with_no_additional_params():
    # If data is None and request_options has no 'additional_body_parameters', should return {}.
    req_opts = RequestOptions()
    codeflash_output = maybe_filter_request_body(None, req_opts, None) # 3.03μs -> 2.77μs (9.54% faster)

def test_none_data_with_request_options_with_additional_params():
    # If data is None and request_options has 'additional_body_parameters', should return its jsonable encoding.
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {"foo": "bar", "num": 42}
    codeflash_output = maybe_filter_request_body(None, req_opts, None) # 5.46μs -> 3.63μs (50.6% faster)

def test_data_is_not_mapping_returns_encoded_data():
    # If data is not a mapping, should return jsonable_encoder(data)
    class Dummy:
        def __init__(self, x):
            self.x = x
    d = Dummy(5)
    codeflash_output = maybe_filter_request_body(d, None, None); result = codeflash_output # 61.9μs -> 59.5μs (3.97% faster)

def test_data_is_mapping_merges_with_additional_params():
    # If data is a dict and request_options has additional params, should merge them
    data = {"a": 1, "b": 2}
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {"b": 3, "c": 4}
    codeflash_output = maybe_filter_request_body(data, req_opts, None); out = codeflash_output # 9.94μs -> 7.27μs (36.8% faster)

def test_data_is_mapping_no_request_options():
    # If data is a dict and no request_options, should just encode data minus omit
    data = {"a": 1, "b": 2}
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 6.44μs -> 4.77μs (35.0% faster)

# 2. Edge Test Cases

def test_omit_removes_value():
    # If omit is set, remove keys whose value is omit
    data = {"a": 1, "b": None, "c": 3}
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 7.55μs -> 4.96μs (52.2% faster)
    # Now set omit to None: nothing is removed
    codeflash_output = maybe_filter_request_body(data, None, 1); out2 = codeflash_output # 4.32μs -> 2.85μs (51.4% faster)

def test_omit_removes_specific_value():
    # Remove keys whose value is exactly the omit object
    OMIT = object()
    data = {"a": 1, "b": OMIT, "c": 3}
    codeflash_output = maybe_filter_request_body(data, None, OMIT); out = codeflash_output
    # If omit is not present, nothing is removed
    codeflash_output = maybe_filter_request_body(data, None, object()); out2 = codeflash_output

def test_data_is_empty_dict():
    # Should handle empty dicts gracefully
    codeflash_output = maybe_filter_request_body({}, None, None) # 5.97μs -> 5.87μs (1.70% faster)

def test_data_is_list():
    # Should encode lists using jsonable_encoder
    data = [1, 2, 3]
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 6.24μs -> 5.02μs (24.2% faster)

def test_data_is_bytes():
    # Should encode bytes as base64 string
    data = b"abc"
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 4.23μs -> 4.38μs (3.54% slower)
    import base64

def test_data_is_path():
    # Should encode PurePath as string
    data = PurePath("/tmp/test.txt")
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 10.5μs -> 11.1μs (5.51% slower)

def test_data_is_datetime():
    # Should encode datetime as ISO string
    now = dt.datetime(2020, 1, 1, 12, 0, 0, tzinfo=dt.timezone.utc)
    codeflash_output = maybe_filter_request_body(now, None, None); out = codeflash_output # 11.6μs -> 12.4μs (6.66% slower)

def test_data_is_date():
    # Should encode date as string
    today = dt.date(2022, 2, 2)
    codeflash_output = maybe_filter_request_body(today, None, None); out = codeflash_output # 4.96μs -> 5.14μs (3.45% slower)

def test_data_is_dataclass():
    # Should encode dataclasses as dicts
    @dataclasses.dataclass
    class Foo:
        x: int
        y: str
    data = Foo(1, "bar")
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 40.8μs -> 38.8μs (5.14% faster)

def test_data_is_tuple():
    # Should encode tuple as list
    data = (1, 2, 3)
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 6.14μs -> 4.89μs (25.6% faster)

def test_data_is_set():
    # Should encode set as list (order not guaranteed)
    data = {1, 2, 3}
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 5.77μs -> 4.58μs (26.1% faster)

def test_data_is_object_with_vars():
    # Should encode object with __dict__ as dict
    class Bar:
        def __init__(self):
            self.x = 7
    data = Bar()
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 55.6μs -> 53.3μs (4.37% faster)

def test_data_is_object_with_dict_method():
    # Should encode object with dict() method
    class Baz:
        def __iter__(self):
            return iter([("foo", 1), ("bar", 2)])
        def __len__(self):
            return 2
    data = Baz()
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 46.0μs -> 40.8μs (12.9% faster)

def test_data_is_mapping_with_non_str_keys():
    # Should encode keys using jsonable_encoder
    data = {1: "a", 2: "b"}
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 7.34μs -> 5.49μs (33.9% faster)

def test_data_and_request_options_both_none_and_omit_is_set():
    # If data and request_options are None, omit is set, should still return None.
    codeflash_output = maybe_filter_request_body(None, None, object()) # 332ns -> 367ns (9.54% slower)

def test_data_is_mapping_and_request_options_is_empty():
    # Should just encode data
    data = {"x": 1}
    req_opts = RequestOptions()
    codeflash_output = maybe_filter_request_body(data, req_opts, None); out = codeflash_output # 7.51μs -> 6.16μs (21.9% faster)

def test_data_is_mapping_and_request_options_additional_params_empty_dict():
    # Should merge with empty dict (no changes)
    data = {"x": 1}
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {}
    codeflash_output = maybe_filter_request_body(data, req_opts, None); out = codeflash_output # 7.01μs -> 5.88μs (19.1% faster)

def test_data_is_mapping_and_request_options_additional_params_overwrites():
    # Should overwrite keys with additional params
    data = {"x": 1}
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {"x": 2, "y": 3}
    codeflash_output = maybe_filter_request_body(data, req_opts, None); out = codeflash_output # 8.90μs -> 6.60μs (34.8% faster)

# 3. Large Scale Test Cases

def test_large_dict_merge_and_omit():
    # Test with large dicts and omit value
    OMIT = object()
    data = {f"key{i}": i if i % 10 != 0 else OMIT for i in range(500)}
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {f"key{i}": -i for i in range(250, 750)}
    codeflash_output = maybe_filter_request_body(data, req_opts, OMIT); out = codeflash_output # 709μs -> 205μs (246% faster)
    # keys 0,10,20,...,490 should be omitted from data, but present if overwritten by additional params
    for i in range(500):
        k = f"key{i}"
        if i % 10 == 0 and i < 250:
            pass
        elif i < 250:
            pass
        else:
            pass
    # keys 500-749 should be present from additional params
    for i in range(500, 750):
        k = f"key{i}"

def test_large_list_encoding():
    # Test with large list input
    data = list(range(1000))
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 307μs -> 77.6μs (296% faster)

def test_large_nested_dict():
    # Test with nested dicts and lists
    data = {
        f"outer{i}": {
            f"inner{j}": j for j in range(10)
        } for i in range(50)
    }
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {"extra": 1}
    codeflash_output = maybe_filter_request_body(data, req_opts, None); out = codeflash_output # 393μs -> 122μs (222% faster)
    # Check structure
    for i in range(50):
        key = f"outer{i}"
        for j in range(10):
            pass

def test_large_set_encoding():
    # Test with a large set
    data = set(range(500))
    codeflash_output = maybe_filter_request_body(data, None, None); out = codeflash_output # 159μs -> 43.4μs (267% faster)

def test_large_merge_with_omit_and_overwrite():
    # Test with large merge and omit, and overwriting
    OMIT = object()
    data = {f"k{i}": OMIT if i % 2 == 0 else i for i in range(100)}
    req_opts = RequestOptions()
    req_opts["additional_body_parameters"] = {f"k{i}": -i for i in range(50, 150)}
    codeflash_output = maybe_filter_request_body(data, req_opts, OMIT); out = codeflash_output # 120μs -> 39.8μs (203% faster)
    for i in range(100):
        k = f"k{i}"
        if i % 2 == 0 and i < 50:
            pass
        elif i < 50:
            pass
        else:
            pass
    for i in range(100, 150):
        k = f"k{i}"
# 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-maybe_filter_request_body-mi78kfm5 and push.