⚡️ Speed up method CSVSink.parse_field_names by 688%

[codeflash-ai]

📄 688% (6.88x) speedup for CSVSink.parse_field_names in supervision/detection/tools/csv_sink.py

⏱️ Runtime : 1.53 millisecond → 195 microseconds (best of 319 runs)

📝 Explanation and details

To optimize the parse_field_names method in the CSVSink class for faster execution, we should minimize the use of inefficient operations and redundant calls. Specifically, eliminating the use of set() and sorted(), which can be costly in terms of time complexity, will help improve the performance. We will also use efficient data structures like list comprehension and dictionary operations.

Here's the optimized version of the parse_field_names method.

In this rewritten method.

1. We avoid using the set() operations which are inherently more computationally intensive due to their need to handle hash calculations and uniqueness checks.
2. We concatenate the custom_keys directly with the detection_keys while ensuring only unique additions, thereby avoiding unnecessary sorting.
3. This approach leverages list comprehension which is more efficient for iteration and condition checks.

Benchmark tests should also be conducted to validate the performance benefits of these changes in realistic scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from __future__ import annotations

import csv
from typing import Any, Dict, List, Optional

# imports
import pytest  # used for our unit tests
from supervision.detection.tools.csv_sink import CSVSink

# Mocking BASE_HEADER for testing purposes
BASE_HEADER = ["base1", "base2"]

# Mocking Detections class for testing purposes
class Detections:
    def __init__(self, data=None):
        self.data = data
from supervision.detection.tools.csv_sink import CSVSink

# unit tests

# Basic Functionality


def test_non_empty_detections_and_empty_custom_data():
    detections = Detections(data={"key3": "value3", "key4": "value4"})
    custom_data = {}
    expected_output = BASE_HEADER + ["key3", "key4"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_non_empty_detections_and_custom_data():
    detections = Detections(data={"key3": "value3", "key4": "value4"})
    custom_data = {"key1": "value1", "key2": "value2"}
    expected_output = BASE_HEADER + ["key1", "key2", "key3", "key4"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

# Edge Cases
def test_overlapping_keys():
    detections = Detections(data={"key1": "value3", "key2": "value4"})
    custom_data = {"key1": "value1", "key2": "value2"}
    expected_output = BASE_HEADER + ["key1", "key2"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_special_characters_in_keys():
    detections = Detections(data={"key_1": "value3", "key-2": "value4"})
    custom_data = {"key 1": "value1", "key@2": "value2"}
    expected_output = BASE_HEADER + ["key 1", "key@2", "key-2", "key_1"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_mixed_data_types_in_custom_data_values():
    detections = Detections(data={"key3": "value3"})
    custom_data = {"key1": 123, "key2": [1, 2, 3]}
    expected_output = BASE_HEADER + ["key1", "key2", "key3"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_large_number_of_keys():
    detections = Detections(data={f"key{i}": f"value{i}" for i in range(1000)})
    custom_data = {f"custom_key{i}": f"value{i}" for i in range(1000)}
    expected_output = BASE_HEADER + sorted([f"key{i}" for i in range(1000)] + [f"custom_key{i}" for i in range(1000)])
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

# Error Handling

def test_detections_is_none():
    detections = None
    custom_data = {"key1": "value1"}
    expected_output = BASE_HEADER + ["key1"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)


def test_large_scale():
    detections = Detections(data={f"key{i}": f"value{i}" for i in range(1000)})
    custom_data = {f"custom_key{i}": f"value{i}" for i in range(1000)}
    expected_output = BASE_HEADER + sorted([f"key{i}" for i in range(1000)] + [f"custom_key{i}" for i in range(1000)])
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import csv
from typing import Any, Dict, List, Optional

# imports
import pytest  # used for our unit tests
from supervision.detection.tools.csv_sink import CSVSink


class Detections:
    def __init__(self, data):
        self.data = data

BASE_HEADER = ["base1", "base2"]
from supervision.detection.tools.csv_sink import CSVSink

# unit tests

def test_basic_input_with_minimal_data():
    # Test with minimal data in detections and empty custom_data
    detections = Detections(data={"key1": "value1"})
    custom_data = {}
    expected = BASE_HEADER + ["key1"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_no_data_provided():
    # Test with both detections.data and custom_data empty
    detections = Detections(data={})
    custom_data = {}
    expected = BASE_HEADER
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_overlapping_keys():
    # Test with overlapping keys in detections.data and custom_data
    detections = Detections(data={"key1": "value1", "key2": "value2"})
    custom_data = {"key2": "custom_value2", "key3": "custom_value3"}
    expected = BASE_HEADER + ["key1", "key2", "key3"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_all_unique_keys():
    # Test with all unique keys in detections.data and custom_data
    detections = Detections(data={"key1": "value1"})
    custom_data = {"key2": "custom_value2"}
    expected = BASE_HEADER + ["key1", "key2"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_large_number_of_keys():
    # Test with a large number of keys in both detections.data and custom_data
    detections = Detections(data={f"key{i}": f"value{i}" for i in range(1000)})
    custom_data = {f"custom_key{i}": f"custom_value{i}" for i in range(1000)}
    expected = BASE_HEADER + sorted([f"key{i}" for i in range(1000)] + [f"custom_key{i}" for i in range(1000)])
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_different_types_of_values():
    # Test with different types of values in custom_data
    detections = Detections(data={"key1": "value1"})
    custom_data = {"key2": 123, "key3": [1, 2, 3]}
    expected = BASE_HEADER + ["key1", "key2", "key3"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_nested_data_structures():
    # Test with nested data structures in detections.data and custom_data
    detections = Detections(data={"key1": {"nested_key": "nested_value"}})
    custom_data = {"key2": {"nested_key": "nested_value"}}
    expected = BASE_HEADER + ["key1", "key2"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_special_characters_in_keys():
    # Test with special characters in keys of detections.data and custom_data
    detections = Detections(data={"key 1!": "value1"})
    custom_data = {"key@2#": "custom_value2"}
    expected = BASE_HEADER + ["key 1!", "key@2#"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_case_sensitivity_in_keys():
    # Test with case sensitivity in keys of detections.data and custom_data
    detections = Detections(data={"key": "value1"})
    custom_data = {"Key": "custom_value2"}
    expected = BASE_HEADER + ["Key", "key"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_predefined_base_header():
    # Test with predefined BASE_HEADER
    detections = Detections(data={"key1": "value1"})
    custom_data = {"key2": "custom_value2"}
    expected = BASE_HEADER + ["key1", "key2"]
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)

def test_performance_with_large_data_sets():
    # Test performance with large data sets
    detections = Detections(data={f"key{i}": f"value{i}" for i in range(1000)})
    custom_data = {f"custom_key{i}": f"custom_value{i}" for i in range(1000)}
    expected = BASE_HEADER + sorted([f"key{i}" for i in range(1000)] + [f"custom_key{i}" for i in range(1000)])
    codeflash_output = CSVSink.parse_field_names(detections, custom_data)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.