⚡️ Speed up function is_json_validation_enabled by 28%

[codeflash-ai]

📄 28% (0.28x) speedup for is_json_validation_enabled in src/datadog_api_client/model_utils.py

⏱️ Runtime : 1.88 milliseconds → 1.47 milliseconds (best of 26 runs)

📝 Explanation and details

The optimized code achieves a 27% speedup by replacing the chained boolean expression with early returns and try-catch logic, reducing the number of operations and attribute lookups.

Key optimizations:

1. Early return for None configuration: Instead of evaluating all conditions in a chained expression, the code immediately returns True when configuration is None, eliminating unnecessary evaluations.

2. Replace hasattr() with try-catch: The original code uses hasattr(configuration, "_disabled_client_side_validations") which internally catches AttributeError anyway. The optimized version directly accesses the attribute in a try block, avoiding the overhead of the hasattr() function call.

3. Variable caching: The optimized code stores configuration._disabled_client_side_validations in a local variable disabled_validations, eliminating repeated attribute access in the final check.

4. Reduced boolean expression complexity: The original chained or expression with three conditions is replaced with structured control flow, reducing the overhead of Python's short-circuit evaluation machinery.

Performance benefits by test case:

• Most effective for normal configurations (46-68% faster): When configuration objects have the disabled validations attribute, the optimization shows the largest gains
• Significant improvement for empty disabled sets (35-50% faster): Common case where validation is enabled
• Good performance for missing attributes (though 54% slower in one edge case): The try-catch handles missing attributes efficiently in most scenarios
• Excellent scaling with large disabled sets (28-35% faster): The variable caching provides consistent benefits regardless of set size

The optimization is particularly effective because it reduces the number of attribute lookups and function calls in the hot path, which are expensive operations in Python.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from src.datadog_api_client.model_utils import is_json_validation_enabled

# unit tests

# Helper class to simulate configuration objects
class DummyConfig:
    def __init__(self, disabled=None):
        self._disabled_client_side_validations = disabled if disabled is not None else set()

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

def test_enabled_with_no_configuration():
    """Should enable validation if configuration is None."""
    codeflash_output = is_json_validation_enabled("type", None) # 836ns -> 741ns (12.8% faster)

def test_enabled_with_configuration_and_empty_disabled_set():
    """Should enable validation if disabled set is empty."""
    config = DummyConfig(set())
    codeflash_output = is_json_validation_enabled("type", config) # 1.17μs -> 780ns (50.4% faster)

def test_disabled_for_keyword_in_disabled_set():
    """Should disable validation if keyword is in disabled set."""
    config = DummyConfig({"type", "enum"})
    codeflash_output = is_json_validation_enabled("type", config) # 1.20μs -> 776ns (54.1% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 322ns -> 240ns (34.2% faster)

def test_enabled_for_keyword_not_in_disabled_set():
    """Should enable validation if keyword is not in disabled set."""
    config = DummyConfig({"enum"})
    codeflash_output = is_json_validation_enabled("type", config) # 1.17μs -> 797ns (46.4% faster)

def test_enabled_for_different_keyword():
    """Should enable validation for unrelated keyword."""
    config = DummyConfig({"maxLength"})
    codeflash_output = is_json_validation_enabled("minLength", config) # 1.33μs -> 850ns (56.4% faster)

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

def test_configuration_without_disabled_attribute():
    """Should enable validation if configuration lacks the attribute."""
    class NoDisabledAttr:
        pass
    config = NoDisabledAttr()
    codeflash_output = is_json_validation_enabled("type", config) # 1.23μs -> 2.71μs (54.6% slower)


def test_disabled_set_is_not_a_set():
    """Should handle disabled attribute as a list or tuple."""
    config = DummyConfig(["type", "enum"])
    codeflash_output = is_json_validation_enabled("type", config) # 1.24μs -> 853ns (45.0% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 507ns -> 402ns (26.1% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 432ns -> 335ns (29.0% faster)

    config2 = DummyConfig(("type",))
    codeflash_output = is_json_validation_enabled("type", config2) # 343ns -> 256ns (34.0% faster)
    codeflash_output = is_json_validation_enabled("enum", config2) # 370ns -> 279ns (32.6% faster)

def test_disabled_set_is_dict():
    """Should handle disabled attribute as a dict (keys)."""
    config = DummyConfig({"type": True, "enum": False})
    # Only keys matter
    codeflash_output = is_json_validation_enabled("type", config) # 1.29μs -> 987ns (30.3% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 425ns -> 302ns (40.7% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 350ns -> 294ns (19.0% faster)

def test_keyword_is_empty_string():
    """Should handle empty string keyword."""
    config = DummyConfig({"", "type"})
    codeflash_output = is_json_validation_enabled("", config) # 1.14μs -> 846ns (35.1% faster)
    codeflash_output = is_json_validation_enabled("type", config) # 425ns -> 349ns (21.8% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 336ns -> 271ns (24.0% faster)

def test_keyword_is_none():
    """Should handle None as keyword."""
    config = DummyConfig({None, "type"})
    codeflash_output = is_json_validation_enabled(None, config) # 1.23μs -> 854ns (43.6% faster)
    codeflash_output = is_json_validation_enabled("type", config) # 446ns -> 276ns (61.6% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 353ns -> 265ns (33.2% faster)

def test_configuration_is_object_with_disabled_as_property():
    """Should handle disabled attribute as a property."""
    class PropertyConfig:
        @property
        def _disabled_client_side_validations(self):
            return {"type", "enum"}
    config = PropertyConfig()
    codeflash_output = is_json_validation_enabled("type", config) # 2.31μs -> 1.72μs (34.1% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 800ns -> 577ns (38.6% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 727ns -> 529ns (37.4% faster)

def test_configuration_is_object_with_disabled_as_method():
    """Should raise if _disabled_client_side_validations is a method."""
    class MethodConfig:
        def _disabled_client_side_validations(self):
            return {"type", "enum"}
    config = MethodConfig()
    with pytest.raises(TypeError):
        is_json_validation_enabled("type", config) # 4.20μs -> 4.00μs (4.87% faster)

def test_configuration_is_not_an_object():
    """Should enable validation if configuration is not an object."""
    # configuration is an int
    codeflash_output = is_json_validation_enabled("type", 123) # 1.45μs -> 2.53μs (42.8% slower)
    # configuration is a string
    codeflash_output = is_json_validation_enabled("type", "not a config") # 849ns -> 1.28μs (33.8% slower)

def test_disabled_set_contains_non_string_elements():
    """Should handle disabled set with non-string elements."""
    config = DummyConfig({"type", 42, None})
    codeflash_output = is_json_validation_enabled("type", config) # 1.11μs -> 815ns (35.8% faster)
    codeflash_output = is_json_validation_enabled(42, config) # 429ns -> 356ns (20.5% faster)
    codeflash_output = is_json_validation_enabled(None, config) # 326ns -> 251ns (29.9% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 340ns -> 257ns (32.3% faster)

def test_disabled_set_is_large_but_keyword_not_present():
    """Should enable validation if keyword not present in large set."""
    large_set = {f"kw{i}" for i in range(1000)}
    config = DummyConfig(large_set)
    codeflash_output = is_json_validation_enabled("not_in_set", config) # 1.25μs -> 882ns (42.2% faster)

def test_disabled_set_is_large_and_keyword_present():
    """Should disable validation if keyword present in large set."""
    large_set = {f"kw{i}" for i in range(1000)}
    config = DummyConfig(large_set)
    codeflash_output = is_json_validation_enabled("kw999", config) # 1.43μs -> 1.02μs (39.7% faster)
    codeflash_output = is_json_validation_enabled("kw0", config) # 560ns -> 307ns (82.4% faster)

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

def test_many_keywords_all_disabled():
    """Should disable validation for all keywords in large set."""
    disabled = {f"key{i}" for i in range(1000)}
    config = DummyConfig(disabled)
    for i in range(1000):
        codeflash_output = is_json_validation_enabled(f"key{i}", config) # 322μs -> 251μs (28.5% faster)

def test_many_keywords_none_disabled():
    """Should enable validation for all keywords not in disabled set."""
    disabled = set()
    config = DummyConfig(disabled)
    for i in range(1000):
        codeflash_output = is_json_validation_enabled(f"key{i}", config) # 291μs -> 215μs (35.5% faster)

def test_mixed_keywords_some_disabled_some_enabled():
    """Should correctly enable/disable for mixed large set."""
    disabled = {f"key{i}" for i in range(0, 1000, 2)}  # even keys disabled
    config = DummyConfig(disabled)
    for i in range(1000):
        if i % 2 == 0:
            codeflash_output = is_json_validation_enabled(f"key{i}", config)
        else:
            codeflash_output = is_json_validation_enabled(f"key{i}", config)

def test_performance_with_large_disabled_set():
    """Should not be slow for large disabled set (under 1000)."""
    import time
    disabled = {f"key{i}" for i in range(1000)}
    config = DummyConfig(disabled)
    start = time.time()
    for i in range(1000):
        is_json_validation_enabled(f"key{i}", config) # 317μs -> 247μs (28.3% faster)
    duration = time.time() - start

def test_performance_with_large_enabled_set():
    """Should not be slow for large enabled set (none disabled)."""
    import time
    config = DummyConfig(set())
    start = time.time()
    for i in range(1000):
        is_json_validation_enabled(f"key{i}", config) # 292μs -> 217μs (35.0% faster)
    duration = time.time() - start

# -------------------
# Determinism Test
# -------------------

def test_determinism():
    """Should always return same result for same input."""
    config = DummyConfig({"type", "enum"})
    codeflash_output = is_json_validation_enabled("type", config); result1 = codeflash_output # 1.14μs -> 831ns (37.5% faster)
    codeflash_output = is_json_validation_enabled("type", config); result2 = codeflash_output # 362ns -> 284ns (27.5% faster)

# -------------------
# Unusual Types Test
# -------------------

def test_keyword_is_int_or_float():
    """Should handle keyword as int or float."""
    config = DummyConfig({42, 3.14})
    codeflash_output = is_json_validation_enabled(42, config) # 1.16μs -> 873ns (33.3% faster)
    codeflash_output = is_json_validation_enabled(3.14, config) # 530ns -> 373ns (42.1% faster)
    codeflash_output = is_json_validation_enabled("type", config) # 402ns -> 305ns (31.8% faster)

def test_disabled_set_is_frozenset():
    """Should handle disabled attribute as frozenset."""
    config = DummyConfig(frozenset({"type", "enum"}))
    codeflash_output = is_json_validation_enabled("type", config) # 1.84μs -> 1.43μs (29.1% faster)
    codeflash_output = is_json_validation_enabled("enum", config) # 454ns -> 305ns (48.9% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 440ns -> 308ns (42.9% faster)

def test_disabled_set_is_string():
    """Should treat string as iterable of chars, not keywords."""
    config = DummyConfig("type")
    # Only single-character keywords would be disabled
    codeflash_output = is_json_validation_enabled("t", config) # 1.28μs -> 970ns (32.3% faster)
    codeflash_output = is_json_validation_enabled("y", config) # 460ns -> 347ns (32.6% faster)
    codeflash_output = is_json_validation_enabled("type", config) # 486ns -> 446ns (8.97% faster)


def test_disabled_set_is_range():
    """Should handle range as disabled set."""
    config = DummyConfig(range(10))
    for i in range(10):
        codeflash_output = is_json_validation_enabled(i, config) # 5.95μs -> 4.76μs (25.0% faster)
    codeflash_output = is_json_validation_enabled(11, config) # 390ns -> 317ns (23.0% faster)
# 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 src.datadog_api_client.model_utils import is_json_validation_enabled


# Helper class for configuration
class DummyConfig:
    def __init__(self, disabled=None):
        # If disabled is None, do not set the attribute
        if disabled is not None:
            self._disabled_client_side_validations = disabled

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

def test_enabled_with_no_configuration():
    # Should return True if configuration is None
    codeflash_output = is_json_validation_enabled("type") # 996ns -> 722ns (38.0% faster)

def test_enabled_with_configuration_no_disabled_attr():
    # Should return True if configuration has no _disabled_client_side_validations attribute
    class NoDisabledAttr:
        pass
    config = NoDisabledAttr()
    codeflash_output = is_json_validation_enabled("type", config) # 1.15μs -> 2.61μs (55.9% slower)

def test_enabled_with_empty_disabled_list():
    # Should return True if _disabled_client_side_validations is empty
    config = DummyConfig([])
    codeflash_output = is_json_validation_enabled("type", config) # 1.24μs -> 737ns (68.4% faster)

def test_disabled_with_keyword_in_disabled_list():
    # Should return False if schema_keyword is in _disabled_client_side_validations
    config = DummyConfig(["type", "format"])
    codeflash_output = is_json_validation_enabled("type", config) # 1.21μs -> 854ns (41.2% faster)
    codeflash_output = is_json_validation_enabled("format", config) # 581ns -> 358ns (62.3% faster)

def test_enabled_with_keyword_not_in_disabled_list():
    # Should return True if schema_keyword is NOT in _disabled_client_side_validations
    config = DummyConfig(["type", "format"])
    codeflash_output = is_json_validation_enabled("maxLength", config) # 1.36μs -> 1.45μs (5.87% slower)

def test_enabled_with_multiple_keywords_not_in_disabled_list():
    # Multiple keywords, none disabled
    config = DummyConfig(["type"])
    for kw in ["maxLength", "minimum", "maximum"]:
        codeflash_output = is_json_validation_enabled(kw, config) # 1.93μs -> 1.61μs (19.6% faster)

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

def test_disabled_with_empty_string_keyword():
    # Should handle empty string as keyword
    config = DummyConfig([""])
    codeflash_output = is_json_validation_enabled("", config) # 1.22μs -> 1.02μs (20.1% faster)

def test_enabled_with_none_keyword():
    # None as keyword should not match any string in disabled list
    config = DummyConfig(["type", "format"])
    codeflash_output = is_json_validation_enabled(None, config) # 1.40μs -> 1.18μs (19.1% faster)

def test_enabled_with_non_string_keyword():
    # Non-string keywords should be handled (e.g., int, tuple)
    config = DummyConfig([1, (2,3)])
    codeflash_output = is_json_validation_enabled(1, config) # 1.19μs -> 940ns (27.0% faster)
    codeflash_output = is_json_validation_enabled((2,3), config) # 699ns -> 534ns (30.9% faster)
    codeflash_output = is_json_validation_enabled(3, config) # 555ns -> 505ns (9.90% faster)

def test_enabled_with_disabled_list_as_set():
    # _disabled_client_side_validations as a set
    config = DummyConfig(set(["type", "format"]))
    codeflash_output = is_json_validation_enabled("type", config) # 1.15μs -> 946ns (21.7% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 502ns -> 388ns (29.4% faster)

def test_enabled_with_disabled_list_as_dict():
    # _disabled_client_side_validations as a dict (should check keys)
    config = DummyConfig({"type": True, "format": True})
    codeflash_output = is_json_validation_enabled("type", config) # 1.22μs -> 1.02μs (19.3% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 497ns -> 364ns (36.5% faster)

def test_enabled_with_disabled_list_as_tuple():
    # _disabled_client_side_validations as a tuple
    config = DummyConfig(("type", "format"))
    codeflash_output = is_json_validation_enabled("type", config) # 1.19μs -> 978ns (22.1% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 522ns -> 416ns (25.5% faster)

def test_enabled_with_disabled_list_as_string():
    # _disabled_client_side_validations as a string (should treat as iterable of chars)
    config = DummyConfig("type")
    # Only single characters will match
    codeflash_output = is_json_validation_enabled("t", config) # 1.22μs -> 1.09μs (12.0% faster)
    codeflash_output = is_json_validation_enabled("type", config) # 701ns -> 578ns (21.3% faster)

def test_enabled_with_disabled_list_is_none():
    # _disabled_client_side_validations is None
    config = DummyConfig(None)
    codeflash_output = is_json_validation_enabled("type", config) # 956ns -> 2.44μs (60.8% slower)

def test_enabled_with_configuration_is_not_object():
    # configuration is an int, string, etc.
    codeflash_output = is_json_validation_enabled("type", 123) # 1.00μs -> 2.77μs (63.8% slower)
    codeflash_output = is_json_validation_enabled("type", "not_a_config") # 799ns -> 1.17μs (31.6% slower)
    codeflash_output = is_json_validation_enabled("type", [1,2,3]) # 755ns -> 1.38μs (45.4% slower)



def test_large_disabled_list_keyword_present():
    # Large _disabled_client_side_validations, keyword present
    disabled = [f"kw{i}" for i in range(1000)]
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("kw999", config) # 17.4μs -> 17.2μs (1.32% faster)

def test_large_disabled_list_keyword_absent():
    # Large _disabled_client_side_validations, keyword absent
    disabled = [f"kw{i}" for i in range(1000)]
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("not_present", config) # 12.8μs -> 12.5μs (2.86% faster)

def test_large_disabled_dict_keyword_present():
    # Large dict, keyword present
    disabled = {f"kw{i}": True for i in range(1000)}
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("kw500", config) # 1.59μs -> 1.27μs (25.7% faster)

def test_large_disabled_dict_keyword_absent():
    # Large dict, keyword absent
    disabled = {f"kw{i}": True for i in range(1000)}
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("not_present", config) # 1.52μs -> 1.36μs (11.8% faster)

def test_large_disabled_set_keyword_present():
    # Large set, keyword present
    disabled = set(f"kw{i}" for i in range(1000))
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("kw123", config) # 1.29μs -> 1.01μs (28.4% faster)

def test_large_disabled_set_keyword_absent():
    # Large set, keyword absent
    disabled = set(f"kw{i}" for i in range(1000))
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("not_present", config) # 1.22μs -> 1.01μs (20.9% faster)

def test_large_disabled_tuple_keyword_present():
    # Large tuple, keyword present
    disabled = tuple(f"kw{i}" for i in range(1000))
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("kw888", config) # 15.3μs -> 14.5μs (6.11% faster)

def test_large_disabled_tuple_keyword_absent():
    # Large tuple, keyword absent
    disabled = tuple(f"kw{i}" for i in range(1000))
    config = DummyConfig(disabled)
    codeflash_output = is_json_validation_enabled("not_present", config) # 11.7μs -> 11.5μs (1.71% faster)

# ---------------------------
# Determinism Test
# ---------------------------

def test_determinism_with_same_inputs():
    # Should always return the same value for same inputs
    config = DummyConfig(["type"])
    for _ in range(10):
        codeflash_output = is_json_validation_enabled("type", config) # 4.10μs -> 3.28μs (25.2% faster)
        codeflash_output = is_json_validation_enabled("maxLength", config)

# ---------------------------
# Miscellaneous/Regression Test
# ---------------------------


def test_disabled_list_is_frozenset():
    # _disabled_client_side_validations is frozenset
    config = DummyConfig(frozenset(["type", "format"]))
    codeflash_output = is_json_validation_enabled("type", config) # 1.14μs -> 932ns (21.9% faster)
    codeflash_output = is_json_validation_enabled("maxLength", config) # 481ns -> 416ns (15.6% faster)

def test_disabled_list_is_range():
    # _disabled_client_side_validations is a range
    config = DummyConfig(range(5))
    codeflash_output = is_json_validation_enabled(3, config) # 2.21μs -> 1.82μs (21.3% faster)
    codeflash_output = is_json_validation_enabled(10, config) # 708ns -> 425ns (66.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_testsv2test_scenarios_py_teststest_thread_py_teststest_version_py_teststest_deserialization_p__replay_test_0.py::test_src_datadog_api_client_model_utils_is_json_validation_enabled	181μs	154μs	18.0%✅

To edit these changes git checkout codeflash/optimize-is_json_validation_enabled-mgcszjn2 and push.