⚡️ Speed up function data_contains_sv_detections by 26%

[codeflash-ai]

📄 26% (0.26x) speedup for data_contains_sv_detections in inference/core/workflows/execution_engine/v1/executor/output_constructor.py

⏱️ Runtime : 2.16 milliseconds → 1.71 milliseconds (best of 46 runs)

📝 Explanation and details

The optimized code replaces inefficient set-based collection with early-return logic, delivering a 26% speedup.

Key optimizations applied:

1. Eliminated unnecessary set operations: The original code created a set(), added boolean results to it, then checked if True in result. The optimized version directly returns True on the first positive match, avoiding set allocation and membership operations entirely.

2. Early termination: Instead of collecting all recursive results, the function now returns immediately when it finds the first sv.Detections instance, significantly reducing unnecessary recursive calls.

Why this leads to speedup:

• Reduced memory allocations: Eliminates set creation for every dict/list processed (4,668 + 153 allocations avoided based on profiler data)
• Shorter execution paths: Early returns mean fewer recursive calls when detections are found early in the data structure
• Better cache locality: Less memory allocation and manipulation improves CPU cache performance

Impact on workloads:
Based on the function references, data_contains_sv_detections is called in workflow output construction loops where it processes batch data. The optimization is particularly beneficial because:

• It's called for every output piece when coordinates conversion is needed
• The early return is especially effective when detections appear early in nested structures
• Large nested structures (like the test cases with 1000+ elements) see the most improvement

Test case performance patterns:

• Best gains (40-50% faster): Cases where detections are found early in nested structures
• Consistent gains (25-35% faster): Most typical use cases with moderate nesting
• Minimal impact: Simple scalar types where the function returns quickly anyway

The optimization maintains identical functionality while being more efficient for the common case where detections exist and can be found without exhaustive search.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_data_contains_sv_detections_when_no_sv_detections_provided	4.14μs	3.22μs	28.8%✅
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_data_contains_sv_detections_when_sv_detections_provided_directly	692ns	608ns	13.8%✅
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_data_contains_sv_detections_when_sv_detections_provided_in_dict	2.58μs	1.84μs	40.4%✅

🌀 Generated Regression Tests and Runtime

import sys
import types

# Now import the function under test, which will use our dummy Detections
from typing import Any

# imports
import pytest
from inference.core.workflows.execution_engine.v1.executor.output_constructor import (
    data_contains_sv_detections,
)


# ---- Function under test ----
# Simulate the presence of supervision.sv.Detections for testing purposes
class DummyDetections:
    pass


# ---- Unit tests ----

# Basic Test Cases


def test_direct_detection_instance():
    """Test with a direct instance of sv.Detections."""
    codeflash_output = data_contains_sv_detections(
        DummyDetections()
    )  # 734ns -> 692ns (6.07% faster)


def test_empty_dict():
    """Test with an empty dictionary."""
    codeflash_output = data_contains_sv_detections({})  # 1.22μs -> 923ns (32.6% faster)


def test_empty_list():
    """Test with an empty list."""
    codeflash_output = data_contains_sv_detections([])  # 991ns -> 788ns (25.8% faster)


def test_dict_with_detection_value():
    """Test with a dict containing a Detections instance as a value."""
    data = {"foo": DummyDetections()}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 1.75μs -> 1.25μs (39.6% faster)


def test_list_with_detection_element():
    """Test with a list containing a Detections instance."""
    data = [1, "a", DummyDetections()]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.04μs -> 1.51μs (34.8% faster)


def test_dict_with_no_detection():
    """Test with a dict that contains no Detections instance."""
    data = {"a": 1, "b": "test", "c": [1, 2, 3]}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.86μs -> 2.22μs (28.7% faster)


def test_list_with_no_detection():
    """Test with a list that contains no Detections instance."""
    data = [None, 0, False, [], {}]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 3.16μs -> 2.40μs (32.0% faster)


# Edge Test Cases


def test_nested_list_with_detection():
    """Test with a deeply nested list containing a Detections instance."""
    data = [0, [1, [2, [DummyDetections()]]]]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.70μs -> 2.13μs (27.1% faster)


def test_nested_dict_with_detection():
    """Test with a deeply nested dict containing a Detections instance."""
    data = {"a": {"b": {"c": DummyDetections()}}}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.19μs -> 1.47μs (49.0% faster)


def test_dict_with_list_of_dicts_with_detection():
    """Test with a dict containing a list of dicts, one of which has a Detections instance."""
    data = {"items": [{"x": 1}, {"y": DummyDetections()}]}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.86μs -> 1.97μs (45.3% faster)


def test_dict_with_list_of_dicts_no_detection():
    """Test with a dict containing a list of dicts, none of which has a Detections instance."""
    data = {"items": [{"x": 1}, {"y": 2}]}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.75μs -> 2.13μs (28.8% faster)


def test_dict_with_multiple_values_some_with_detection():
    """Test with a dict with multiple values, only some contain Detections."""
    data = {"a": 1, "b": DummyDetections(), "c": [3, 4]}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.59μs -> 1.94μs (33.5% faster)


def test_tuple_not_supported_type():
    """Test with a tuple (should return False, as only list/dict are recursed)."""
    data = (DummyDetections(),)
    codeflash_output = data_contains_sv_detections(
        data
    )  # 620ns -> 722ns (14.1% slower)


def test_set_not_supported_type():
    """Test with a set (should return False, as only list/dict are recursed)."""
    data = {DummyDetections()}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 616ns -> 596ns (3.36% faster)


def test_string_input():
    """Test with a string input."""
    data = "not a detection"
    codeflash_output = data_contains_sv_detections(
        data
    )  # 595ns -> 580ns (2.59% faster)


def test_int_input():
    """Test with an integer input."""
    data = 42
    codeflash_output = data_contains_sv_detections(
        data
    )  # 603ns -> 687ns (12.2% slower)


def test_none_input():
    """Test with None input."""
    codeflash_output = data_contains_sv_detections(
        None
    )  # 585ns -> 642ns (8.88% slower)


def test_dict_with_falsey_values():
    """Test with a dict with only falsey values."""
    data = {"a": None, "b": 0, "c": False, "d": ""}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.90μs -> 2.04μs (41.8% faster)


def test_list_with_falsey_values():
    """Test with a list of only falsey values."""
    data = [None, 0, False, ""]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.42μs -> 1.80μs (34.2% faster)


def test_dict_with_detection_and_falsey_values():
    """Test with a dict with a Detections instance and falsey values."""
    data = {"a": None, "b": DummyDetections(), "c": False}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.35μs -> 1.68μs (40.4% faster)


def test_list_with_detection_and_falsey_values():
    """Test with a list with a Detections instance and falsey values."""
    data = [None, DummyDetections(), False]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.03μs -> 1.53μs (32.8% faster)


def test_dict_with_list_with_dict_with_detection():
    """Test with a dict -> list -> dict -> Detections."""
    data = {"foo": [1, {"bar": DummyDetections()}]}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.62μs -> 2.08μs (25.7% faster)


def test_dict_with_list_with_dict_no_detection():
    """Test with a dict -> list -> dict -> no Detections."""
    data = {"foo": [1, {"bar": 2}]}
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.51μs -> 1.95μs (28.5% faster)


def test_list_with_dict_with_list_with_detection():
    """Test with a list -> dict -> list -> Detections."""
    data = [{"foo": [DummyDetections()]}]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.19μs -> 1.68μs (30.0% faster)


def test_list_with_dict_with_list_no_detection():
    """Test with a list -> dict -> list -> no Detections."""
    data = [{"foo": [1, 2, 3]}]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 2.66μs -> 2.02μs (31.7% faster)


# Large Scale Test Cases


def test_large_list_with_detection_at_end():
    """Test with a large list where the Detections instance is at the end."""
    data = [None] * 999 + [DummyDetections()]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 132μs -> 117μs (13.1% faster)


def test_large_list_no_detection():
    """Test with a large list with no Detections instance."""
    data = [0] * 1000
    codeflash_output = data_contains_sv_detections(
        data
    )  # 132μs -> 116μs (13.9% faster)


def test_large_nested_dict_with_detection():
    """Test with a large nested dict where Detections is deeply nested."""
    data = current = {}
    for i in range(999):
        new_dict = {}
        current["x"] = new_dict
        current = new_dict
    current["y"] = DummyDetections()
    codeflash_output = data_contains_sv_detections(
        data
    )  # 214μs -> 149μs (43.1% faster)


def test_large_nested_dict_no_detection():
    """Test with a large nested dict with no Detections instance."""
    data = current = {}
    for i in range(999):
        new_dict = {}
        current["x"] = new_dict
        current = new_dict
    current["y"] = 123
    codeflash_output = data_contains_sv_detections(
        data
    )  # 208μs -> 146μs (42.7% faster)


def test_large_list_of_dicts_with_detection():
    """Test with a large list of dicts, only one contains Detections."""
    data = [{"a": 1} for _ in range(999)]
    data.append({"a": DummyDetections()})
    codeflash_output = data_contains_sv_detections(
        data
    )  # 317μs -> 242μs (31.2% faster)


def test_large_list_of_dicts_no_detection():
    """Test with a large list of dicts, none contains Detections."""
    data = [{"a": 1} for _ in range(1000)]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 315μs -> 240μs (31.1% faster)


# Mutation detection: make sure the function doesn't return True for non-Detections
def test_similar_but_not_detection():
    """Test with an object that looks like Detections but isn't."""

    class NotDetections:
        pass

    data = NotDetections()
    codeflash_output = data_contains_sv_detections(
        data
    )  # 920ns -> 804ns (14.4% faster)


# Mutation detection: make sure function doesn't return False when Detections is present
def test_detection_in_multiple_places():
    """Test with multiple Detections in different places."""
    data = [DummyDetections(), {"foo": DummyDetections()}, [[DummyDetections()]]]
    codeflash_output = data_contains_sv_detections(
        data
    )  # 3.16μs -> 2.07μs (53.1% faster)


# 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-data_contains_sv_detections-miqipb1q and push.