⚡️ Speed up function val2list by 229%

[codeflash-ai]

📄 229% (2.29x) speedup for val2list in kornia/contrib/models/efficient_vit/utils/list.py

⏱️ Runtime : 58.3 microseconds → 17.7 microseconds (best of 880 runs)

📝 Explanation and details

Explanation.

1. Type Checking Optimization: The original code converts both lists and tuples into lists using list(x), which is unnecessary for lists. By returning x directly if x is already a list, we optimize by avoiding an unnecessary conversion when x is a list.

2. List Multiplication: Replaced the list comprehension with list multiplication [x] * repeat_time for the case when x is neither a list nor a tuple. List multiplication is faster and more concise than using a list comprehension in this case.

These small optimizations improve the performance slightly while retaining the original functionality.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from __future__ import annotations

from typing import Any, Union

# imports
import pytest  # used for our unit tests
from kornia.contrib.models.efficient_vit.utils.list import val2list

# unit tests

def test_basic_functionality():
    # Test single integer input
    codeflash_output = val2list(5)
    # Test single string input
    codeflash_output = val2list("a")
    # Test single float input
    codeflash_output = val2list(3.14)

def test_list_and_tuple_conversion():
    # Test input is already a list
    codeflash_output = val2list([1, 2, 3])
    # Test input is a tuple
    codeflash_output = val2list((1, 2, 3))

def test_repeat_functionality():
    # Test single value with repeat
    codeflash_output = val2list(5, repeat_time=3)
    # Test string with repeat
    codeflash_output = val2list("a", repeat_time=2)

def test_edge_cases():
    # Test empty list input
    codeflash_output = val2list([])
    # Test empty tuple input
    codeflash_output = val2list(())
    # Test repeat time is zero
    codeflash_output = val2list(5, repeat_time=0)
    # Test repeat time is negative
    codeflash_output = val2list(5, repeat_time=-1)

def test_complex_types():
    # Test input is a list of lists
    codeflash_output = val2list([[1, 2], [3, 4]])
    # Test input is a tuple of tuples
    codeflash_output = val2list(((1, 2), (3, 4)))


def test_large_scale():
    # Test large list input
    codeflash_output = val2list(list(range(1000)))
    # Test large repeat time
    codeflash_output = val2list(1, repeat_time=1000)

def test_type_variability():
    # Test mixed type list input
    codeflash_output = val2list([1, "a", 3.14])
    # Test mixed type tuple input
    codeflash_output = val2list((1, "a", 3.14))

def test_rare_edge_cases():
    # Test None as input
    codeflash_output = val2list(None)
    codeflash_output = val2list(None, repeat_time=3)
    
    # Test boolean values
    codeflash_output = val2list(True)
    codeflash_output = val2list(False, repeat_time=2)
    
    # Test function or callable as input
    codeflash_output = val2list(len)
    codeflash_output = val2list(lambda x: x, repeat_time=2)
    
    # Test nested structures
    codeflash_output = val2list([(1, 2), (3, 4)])
    codeflash_output = val2list(([1, 2], [3, 4]))
    
    # Test immutable vs mutable types
    codeflash_output = val2list("test", repeat_time=2)
    codeflash_output = val2list({"key": "value"}, repeat_time=2)
    
    # Test special numbers
    codeflash_output = val2list(float('inf'))
    codeflash_output = val2list(float('nan'), repeat_time=2)
    
    # Test custom objects
    class MyClass: pass
    
    # Test empty string
    codeflash_output = val2list("")
    codeflash_output = val2list("", repeat_time=2)
    
    # Test nested repeats
    codeflash_output = val2list([5], repeat_time=3)
# 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

from typing import Any, Union

# imports
import pytest  # used for our unit tests
from kornia.contrib.models.efficient_vit.utils.list import val2list

# unit tests

def test_single_non_iterable_value():
    # Test with a single integer
    codeflash_output = val2list(5)
    # Test with a single character
    codeflash_output = val2list('a')

def test_list_input():
    # Test with a list of integers
    codeflash_output = val2list([1, 2, 3])
    # Test with a list of strings
    codeflash_output = val2list(['x', 'y', 'z'])

def test_tuple_input():
    # Test with a tuple of integers
    codeflash_output = val2list((4, 5, 6))
    # Test with a tuple of strings
    codeflash_output = val2list(('a', 'b', 'c'))

def test_empty_list_and_tuple():
    # Test with an empty list
    codeflash_output = val2list([])
    # Test with an empty tuple
    codeflash_output = val2list(())

def test_none_input():
    # Test with None as input
    codeflash_output = val2list(None)

def test_repeat_time_zero():
    # Test with repeat_time set to 0
    codeflash_output = val2list(10, repeat_time=0)
    # Test with repeat_time set to 0 for a string
    codeflash_output = val2list('test', repeat_time=0)

def test_repetition_of_non_iterable():
    # Test repeating a single integer
    codeflash_output = val2list(3, repeat_time=3)
    # Test repeating a single character
    codeflash_output = val2list('a', repeat_time=2)

def test_repetition_of_iterable():
    # Test repeating a list (should not repeat)
    codeflash_output = val2list([1, 2], repeat_time=2)

def test_nested_list():
    # Test with a nested list
    codeflash_output = val2list([[1, 2], [3, 4]])

def test_nested_tuple():
    # Test with a nested tuple
    codeflash_output = val2list(((1, 2), (3, 4)))

def test_mixed_types():
    # Test with a tuple of mixed types
    codeflash_output = val2list((1, 'a', [2, 3]))

def test_large_list():
    # Test with a large list
    codeflash_output = val2list(list(range(1000)))

def test_large_repetition():
    # Test with a large repetition
    codeflash_output = val2list(7, repeat_time=1000)

# Performance test (not typically included in unit tests due to time constraints)
@pytest.mark.skip(reason="Performance test - not usually part of unit tests")

To edit these changes git checkout codeflash/optimize-val2list-m8ocf85w and push.

[github-actions]

This pull request has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs within 7 days. Thank you for your contributions!