⚡️ Speed up function extract_value_type_hint by 648%

[codeflash-ai]

📄 648% (6.48x) speedup for extract_value_type_hint in gradio/sketch/utils.py

⏱️ Runtime : 2.20 milliseconds → 294 microseconds (best of 51 runs)

📝 Explanation and details

The optimization achieves a 647% speedup by avoiding the expensive inspect.signature() call in the common case where functions have __annotations__.

Key optimization:

• Fast path: Check func.__annotations__ first (simple attribute lookup) instead of always calling inspect.signature()
• Expensive fallback: Only use inspect.signature() when __annotations__ is unavailable or doesn't contain "value"

Why this works:
The line profiler shows inspect.signature() consumed 87.4% of execution time (5.13ms out of 5.87ms total). The optimized version accesses func.__annotations__ directly, which is a fast dictionary lookup available on most Python functions. Only 7 out of 184 test cases needed the expensive fallback.

Performance by test case type:

• Functions with annotated 'value' parameter: 1200-1600% faster (most common case)
• Functions without 'value' parameter: 4-8% slower (rare case, acceptable trade-off)
• Functions with 'value' but no annotation: 8-12% slower (uncommon case)
• Large-scale tests: Still 1300%+ faster even with complex Union types

The optimization successfully targets the bottleneck while maintaining identical behavior and outputs across all test scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import inspect
from typing import Any, Dict, List, Optional, Union

# imports
import pytest  # used for our unit tests
from gradio.sketch.utils import extract_value_type_hint

# unit tests

# --- Basic Test Cases ---

def test_basic_int_annotation():
    # Test with a function that has 'value: int'
    def f(value: int): pass
    codeflash_output = extract_value_type_hint(f) # 20.4μs -> 1.47μs (1291% faster)

def test_basic_str_annotation():
    # Test with a function that has 'value: str'
    def f(value: str): pass
    codeflash_output = extract_value_type_hint(f) # 19.6μs -> 1.26μs (1458% faster)

def test_basic_float_annotation():
    # Test with a function that has 'value: float'
    def f(value: float): pass
    codeflash_output = extract_value_type_hint(f) # 20.1μs -> 1.39μs (1343% faster)

def test_basic_bool_annotation():
    # Test with a function that has 'value: bool'
    def f(value: bool): pass
    codeflash_output = extract_value_type_hint(f) # 19.2μs -> 1.41μs (1264% faster)

def test_basic_no_annotation():
    # Test with a function that has 'value' but no annotation
    def f(value): pass
    codeflash_output = extract_value_type_hint(f) # 18.0μs -> 21.4μs (15.8% slower)

def test_basic_other_param_names():
    # Test with a function that does not have 'value' param
    def f(x: int): pass
    codeflash_output = extract_value_type_hint(f) # 18.2μs -> 19.4μs (6.30% slower)

def test_basic_multiple_params_with_value():
    # Test with multiple params, one named 'value'
    def f(a, value: str, b): pass
    codeflash_output = extract_value_type_hint(f) # 22.1μs -> 1.33μs (1562% faster)

# --- Edge Test Cases ---

def test_edge_union_annotation():
    # Test with Union type annotation
    def f(value: Union[int, str]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.46μs (1240% faster)

def test_edge_optional_annotation():
    # Optional[X] is Union[X, NoneType]
    def f(value: Optional[int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.43μs (1263% faster)

def test_edge_union_with_typing_types():
    # Union with types that don't have __name__
    def f(value: Union[List[int], Dict[str, int]]): pass
    # Should return "list | dict"
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.42μs (1275% faster)

def test_edge_complex_typing_annotation():
    # Annotation like List[str]
    def f(value: List[str]): pass
    # Should return "List[str]"
    codeflash_output = extract_value_type_hint(f) # 19.7μs -> 1.47μs (1242% faster)

def test_edge_typing_any_annotation():
    # Annotation is Any
    def f(value: Any): pass
    codeflash_output = extract_value_type_hint(f) # 19.4μs -> 1.39μs (1299% faster)

def test_edge_value_is_keyword_only():
    # 'value' is a keyword-only parameter
    def f(a, *, value: float): pass
    codeflash_output = extract_value_type_hint(f) # 21.4μs -> 1.44μs (1387% faster)

def test_edge_value_is_positional_only():
    # 'value' is positional-only (Python 3.8+)
    def f(value: int, /): pass
    codeflash_output = extract_value_type_hint(f) # 19.3μs -> 1.41μs (1271% faster)

def test_edge_value_with_default_and_annotation():
    # 'value' has a default and an annotation
    def f(value: str = "default"): pass
    codeflash_output = extract_value_type_hint(f) # 20.0μs -> 1.36μs (1371% faster)

def test_edge_value_with_default_no_annotation():
    # 'value' has a default but no annotation
    def f(value="default"): pass
    codeflash_output = extract_value_type_hint(f) # 19.4μs -> 21.2μs (8.31% slower)

def test_edge_value_with_forward_ref():
    # Forward reference annotation
    def f(value: "int"): pass
    # Forward refs are stored as strings, so str(param.annotation) == 'int'
    codeflash_output = extract_value_type_hint(f) # 19.8μs -> 1.43μs (1286% faster)

def test_edge_value_with_custom_class():
    class Custom: pass
    def f(value: Custom): pass
    codeflash_output = extract_value_type_hint(f) # 19.1μs -> 1.41μs (1260% faster)

def test_edge_value_with_union_of_custom_and_builtin():
    class Custom: pass
    def f(value: Union[Custom, int]): pass
    codeflash_output = extract_value_type_hint(f) # 20.2μs -> 1.53μs (1217% faster)

def test_edge_value_with_union_of_none_and_custom():
    class Custom: pass
    def f(value: Union[Custom, None]): pass
    codeflash_output = extract_value_type_hint(f) # 19.6μs -> 1.55μs (1166% faster)

def test_edge_value_with_union_of_multiple_types():
    def f(value: Union[int, str, float, bool]): pass
    codeflash_output = extract_value_type_hint(f) # 19.8μs -> 1.52μs (1197% faster)

def test_edge_value_with_union_of_typing_and_builtin():
    def f(value: Union[List[int], int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.3μs -> 1.44μs (1245% faster)

def test_edge_value_with_union_of_type_and_type():
    def f(value: Union[type, int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.6μs -> 1.50μs (1204% faster)

def test_edge_value_with_union_of_str_and_none():
    def f(value: Optional[str]): pass
    codeflash_output = extract_value_type_hint(f) # 19.9μs -> 1.49μs (1241% faster)

def test_edge_value_with_union_of_list_and_none():
    def f(value: Optional[list]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.48μs (1219% faster)

def test_edge_value_with_union_of_custom_and_none():
    class Foo: pass
    def f(value: Optional[Foo]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.52μs (1184% faster)

def test_edge_value_with_union_of_custom_and_typing():
    class Foo: pass
    def f(value: Union[Foo, List[int]]): pass
    codeflash_output = extract_value_type_hint(f) # 20.2μs -> 1.35μs (1396% faster)

def test_edge_value_with_union_of_multiple_custom_types():
    class Foo: pass
    class Bar: pass
    def f(value: Union[Foo, Bar]): pass
    codeflash_output = extract_value_type_hint(f) # 19.3μs -> 1.52μs (1173% faster)

def test_edge_value_with_union_of_custom_typing_and_builtin():
    class Foo: pass
    def f(value: Union[Foo, List[int], int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.9μs -> 1.55μs (1179% faster)

def test_edge_value_with_union_of_none_only():
    def f(value: Union[None]): pass
    codeflash_output = extract_value_type_hint(f) # 20.1μs -> 1.48μs (1257% faster)

def test_edge_value_with_union_of_any_and_int():
    def f(value: Union[Any, int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.7μs -> 1.55μs (1169% faster)

def test_edge_value_with_union_of_str_and_bytes():
    def f(value: Union[str, bytes]): pass
    codeflash_output = extract_value_type_hint(f) # 19.4μs -> 1.48μs (1211% faster)

def test_edge_value_with_union_of_tuple_and_dict():
    def f(value: Union[tuple, dict]): pass
    codeflash_output = extract_value_type_hint(f) # 19.7μs -> 1.53μs (1184% faster)

def test_edge_value_with_union_of_list_and_dict():
    def f(value: Union[list, dict]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.46μs (1240% faster)

def test_edge_value_with_union_of_list_and_custom():
    class Foo: pass
    def f(value: Union[list, Foo]): pass
    codeflash_output = extract_value_type_hint(f) # 20.3μs -> 1.53μs (1226% faster)

def test_edge_value_with_union_of_custom_and_custom():
    class Foo: pass
    class Bar: pass
    def f(value: Union[Foo, Bar]): pass
    codeflash_output = extract_value_type_hint(f) # 19.7μs -> 1.49μs (1225% faster)

def test_edge_value_with_union_of_custom_and_none_and_builtin():
    class Foo: pass
    def f(value: Union[Foo, None, int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.53μs (1173% faster)

def test_edge_value_with_union_of_multiple_builtin_types():
    def f(value: Union[int, float, str, bool, bytes, list, dict, tuple]): pass
    codeflash_output = extract_value_type_hint(f) # 19.7μs -> 1.59μs (1139% faster)

def test_edge_value_with_union_of_custom_typing_and_builtin_and_none():
    class Foo: pass
    def f(value: Union[Foo, List[int], int, None]): pass
    codeflash_output = extract_value_type_hint(f) # 19.4μs -> 1.53μs (1167% faster)

def test_edge_value_with_union_of_custom_and_typing_and_builtin():
    class Foo: pass
    def f(value: Union[Foo, List[int], int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.9μs -> 1.50μs (1229% faster)

def test_edge_value_with_union_of_typing_and_typing():
    def f(value: Union[List[int], Dict[str, int]]): pass
    codeflash_output = extract_value_type_hint(f) # 19.8μs -> 1.51μs (1207% faster)

def test_edge_value_with_union_of_typing_and_builtin_and_none():
    def f(value: Union[List[int], int, None]): pass
    codeflash_output = extract_value_type_hint(f) # 19.6μs -> 1.48μs (1226% faster)

def test_edge_value_with_union_of_typing_and_typing_and_none():
    def f(value: Union[List[int], Dict[str, int], None]): pass
    codeflash_output = extract_value_type_hint(f) # 19.4μs -> 1.48μs (1210% faster)

def test_edge_value_with_union_of_typing_and_typing_and_typing():
    def f(value: Union[List[int], Dict[str, int], List[str]]): pass
    codeflash_output = extract_value_type_hint(f) # 20.1μs -> 1.53μs (1217% faster)

def test_edge_value_with_union_of_typing_and_typing_and_builtin():
    def f(value: Union[List[int], Dict[str, int], int]): pass
    codeflash_output = extract_value_type_hint(f) # 19.9μs -> 1.50μs (1229% faster)

def test_edge_value_with_union_of_typing_and_typing_and_builtin_and_none():
    def f(value: Union[List[int], Dict[str, int], int, None]): pass
    codeflash_output = extract_value_type_hint(f) # 19.5μs -> 1.48μs (1218% faster)

def test_edge_value_with_union_of_typing_and_typing_and_builtin_and_custom():
    class Foo: pass
    def f(value: Union[List[int], Dict[str, int], int, Foo]): pass
    codeflash_output = extract_value_type_hint(f) # 20.1μs -> 1.57μs (1184% faster)

def test_edge_value_with_union_of_typing_and_typing_and_builtin_and_custom_and_none():
    class Foo: pass
    def f(value: Union[List[int], Dict[str, int], int, Foo, None]): pass
    codeflash_output = extract_value_type_hint(f) # 19.8μs -> 1.47μs (1248% faster)

def test_edge_value_with_union_of_typing_and_typing_and_builtin_and_custom_and_custom2():
    class Foo: pass
    class Bar: pass
    def f(value: Union[List[int], Dict[str, int], int, Foo, Bar]): pass
    codeflash_output = extract_value_type_hint(f) # 20.3μs -> 1.51μs (1241% faster)

# --- Large Scale Test Cases ---

def test_large_scale_many_union_types():
    # Union of 100 different custom types
    classes = []
    for i in range(100):
        classes.append(type(f"Custom{i}", (), {}))
    union_type = Union[tuple(classes)]
    def f(value: union_type): pass
    expected = " | ".join([c.__name__ for c in classes])
    codeflash_output = extract_value_type_hint(f) # 22.0μs -> 1.58μs (1287% faster)

def test_large_scale_many_builtin_types():
    # Union of 50 built-in types
    builtin_types = [int, float, str, bool, bytes, list, dict, tuple, set, frozenset, complex, range, memoryview, bytearray, type, object]
    builtin_types = builtin_types * 3 + [int, float]  # to reach 50
    union_type = Union[tuple(builtin_types[:50])]
    def f(value: union_type): pass
    expected = " | ".join([t.__name__ for t in builtin_types[:50]])
    codeflash_output = extract_value_type_hint(f) # 20.6μs -> 1.46μs (1318% faster)

def test_large_scale_many_typing_types():
    # Union of 10 typing types and 10 custom types
    typing_types = [List[int], Dict[str, int], List[str], Dict[int, str], List[float], Dict[float, str], List[bool], Dict[bool, str], List[bytes], Dict[bytes, str]]
    custom_types = [type(f"Custom{i}", (), {}) for i in range(10)]
    union_type = Union[tuple(typing_types + custom_types)]
    def f(value: union_type): pass
    expected = " | ".join(
        ["list", "dict", "list", "dict", "list", "dict", "list", "dict", "list", "dict"] +
        [c.__name__ for c in custom_types]
    )
    codeflash_output = extract_value_type_hint(f) # 20.6μs -> 1.57μs (1209% faster)

def test_large_scale_union_with_none_and_any():
    # Union of 10 custom types and None and Any
    custom_types = [type(f"Custom{i}", (), {}) for i in range(10)]
    union_type = Union[tuple(custom_types + [type(None), Any])]
    def f(value: union_type): pass
    expected = " | ".join([c.__name__ for c in custom_types] + ["NoneType", "Any"])
    codeflash_output = extract_value_type_hint(f) # 20.1μs -> 1.46μs (1278% faster)

def test_large_scale_union_with_mixed_types():
    # Union of 20 mixed types (custom, builtin, typing, None, Any)
    custom_types = [type(f"Custom{i}", (), {}) for i in range(5)]
    builtin_types = [int, float, str, bool, bytes]
    typing_types = [List[int], Dict[str, int], List[str], Dict[int, str], List[float]]
    mixed_types = custom_types + builtin_types + typing_types + [type(None), Any]
    union_type = Union[tuple(mixed_types)]
    def f(value: union_type): pass
    expected = " | ".join(
        [c.__name__ for c in custom_types] +
        [t.__name__ for t in builtin_types] +
        ["list", "dict", "list", "dict", "list"] +
        ["NoneType", "Any"]
    )
    codeflash_output = extract_value_type_hint(f) # 19.9μs -> 1.46μs (1262% faster)

def test_large_scale_function_without_value_param():
    # Function with 1000 params, none named 'value'
    def f(**kwargs): pass
    codeflash_output = extract_value_type_hint(f) # 18.6μs -> 20.2μs (7.99% slower)

def test_large_scale_function_with_value_and_no_annotation():
    # Function with 1000 params, 'value' present but no annotation
    def f(a, b, c, d, e, value, **kwargs): pass
    codeflash_output = extract_value_type_hint(f) # 24.9μs -> 26.2μs (4.92% slower)

def test_large_scale_function_with_value_and_annotation():
    # Function with 1000 params, 'value' present and annotated
    def f(a, b, c, d, e, value: int, **kwargs): pass
    codeflash_output = extract_value_type_hint(f) # 25.8μs -> 1.36μs (1791% faster)

def test_large_scale_function_with_value_and_union_annotation():
    # Function with 1000 params, 'value' present and annotated as Union
    def f(a, b, c, d, e, value: Union[int, str], **kwargs): pass
    codeflash_output = extract_value_type_hint(f) # 24.9μs -> 1.53μs (1530% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import inspect
from typing import Any, Dict, List, Optional, Union

# imports
import pytest  # used for our unit tests
from gradio.sketch.utils import extract_value_type_hint

# unit tests

# --- Basic Test Cases ---

def test_value_param_with_int_annotation():
    # Function with 'value' parameter annotated as int
    def func(value: int): pass
    codeflash_output = extract_value_type_hint(func) # 20.7μs -> 1.56μs (1224% faster)

def test_value_param_with_str_annotation():
    # Function with 'value' parameter annotated as str
    def func(value: str): pass
    codeflash_output = extract_value_type_hint(func) # 20.3μs -> 1.43μs (1320% faster)

def test_value_param_with_float_annotation():
    # Function with 'value' parameter annotated as float
    def func(value: float): pass
    codeflash_output = extract_value_type_hint(func) # 19.8μs -> 1.40μs (1315% faster)

def test_value_param_with_bool_annotation():
    # Function with 'value' parameter annotated as bool
    def func(value: bool): pass
    codeflash_output = extract_value_type_hint(func) # 19.2μs -> 1.45μs (1229% faster)

def test_value_param_with_union_annotation():
    # Function with 'value' parameter annotated as Union[int, str]
    def func(value: Union[int, str]): pass
    codeflash_output = extract_value_type_hint(func) # 19.7μs -> 1.47μs (1237% faster)

def test_value_param_with_optional_annotation():
    # Function with 'value' parameter annotated as Optional[int]
    def func(value: Optional[int]): pass
    # Optional[int] is Union[int, NoneType]
    codeflash_output = extract_value_type_hint(func) # 19.7μs -> 1.44μs (1264% faster)

def test_value_param_with_list_annotation():
    # Function with 'value' parameter annotated as List[int]
    def func(value: List[int]): pass
    # List[int] does not have __name__, so str(param.annotation) is used
    codeflash_output = extract_value_type_hint(func) # 19.0μs -> 1.46μs (1198% faster)

def test_value_param_with_dict_annotation():
    # Function with 'value' parameter annotated as Dict[str, int]
    def func(value: Dict[str, int]): pass
    codeflash_output = extract_value_type_hint(func) # 19.6μs -> 1.45μs (1251% faster)

def test_value_param_with_any_annotation():
    # Function with 'value' parameter annotated as Any
    def func(value: Any): pass
    codeflash_output = extract_value_type_hint(func) # 19.7μs -> 1.44μs (1273% faster)

def test_value_param_without_annotation():
    # Function with 'value' parameter but no annotation
    def func(value): pass
    codeflash_output = extract_value_type_hint(func) # 18.9μs -> 21.4μs (11.9% slower)

# --- Edge Test Cases ---

def test_no_value_param():
    # Function with no 'value' parameter
    def func(foo: int): pass
    codeflash_output = extract_value_type_hint(func) # 18.2μs -> 19.1μs (4.46% slower)


def test_value_param_with_complex_union():
    # Function with 'value' parameter annotated as Union[int, str, float, bool]
    def func(value: Union[int, str, float, bool]): pass
    codeflash_output = extract_value_type_hint(func) # 21.9μs -> 1.74μs (1154% faster)

def test_value_param_with_custom_class():
    # Function with 'value' parameter annotated as a custom class
    class CustomClass: pass
    def func(value: CustomClass): pass
    codeflash_output = extract_value_type_hint(func) # 20.2μs -> 1.39μs (1353% faster)

def test_value_param_with_forward_ref():
    # Function with 'value' parameter annotated as a string (forward reference)
    def func(value: 'CustomClass'): pass
    # Forward refs are stored as strings, so str(param.annotation) is used
    codeflash_output = extract_value_type_hint(func) # 19.7μs -> 1.48μs (1235% faster)

def test_value_param_with_type_annotation():
    # Function with 'value' parameter annotated as 'type'
    def func(value: type): pass
    codeflash_output = extract_value_type_hint(func) # 19.1μs -> 1.41μs (1256% faster)

def test_value_param_with_callable_annotation():
    # Function with 'value' parameter annotated as 'Callable'
    from collections.abc import Callable
    def func(value: Callable): pass
    codeflash_output = extract_value_type_hint(func) # 19.6μs -> 1.46μs (1243% faster)

def test_value_param_with_tuple_annotation():
    # Function with 'value' parameter annotated as Tuple[int, str]
    from typing import Tuple
    def func(value: Tuple[int, str]): pass
    codeflash_output = extract_value_type_hint(func) # 19.4μs -> 1.47μs (1224% faster)

def test_value_param_with_union_of_custom_and_builtin():
    # Function with 'value' parameter annotated as Union[CustomClass, int]
    class CustomClass: pass
    def func(value: Union[CustomClass, int]): pass
    codeflash_output = extract_value_type_hint(func) # 19.7μs -> 1.54μs (1179% faster)

def test_value_param_with_none_annotation():
    # Function with 'value' parameter annotated as None
    def func(value: type(None)): pass
    codeflash_output = extract_value_type_hint(func) # 19.1μs -> 1.49μs (1178% faster)

def test_value_param_with_annotation_as_object():
    # Function with 'value' parameter annotated as object
    def func(value: object): pass
    codeflash_output = extract_value_type_hint(func) # 19.4μs -> 1.41μs (1280% faster)

def test_value_param_with_annotation_as_bytes():
    # Function with 'value' parameter annotated as bytes
    def func(value: bytes): pass
    codeflash_output = extract_value_type_hint(func) # 19.8μs -> 1.38μs (1333% faster)

def test_value_param_with_annotation_as_complex():
    # Function with 'value' parameter annotated as complex
    def func(value: complex): pass
    codeflash_output = extract_value_type_hint(func) # 19.5μs -> 1.46μs (1238% faster)

# --- Large Scale Test Cases ---

def test_large_union_type_hint():
    # Function with 'value' parameter annotated as Union of 100 types
    class Dummy: pass
    types = tuple(type(f"type_{i}", (), {}) for i in range(100))
    union_type = Union[types]
    def func(value: union_type): pass
    # Should join all class names with ' | '
    expected = " | ".join(cls.__name__ for cls in types)
    codeflash_output = extract_value_type_hint(func) # 21.6μs -> 1.52μs (1324% faster)

def test_large_list_type_hint():
    # Function with 'value' parameter annotated as List of 999 elements (simulated)
    # List[int] is the annotation, but the function only needs to handle the type
    def func(value: List[int]): pass
    codeflash_output = extract_value_type_hint(func) # 20.2μs -> 1.50μs (1249% faster)

def test_large_dict_type_hint():
    # Function with 'value' parameter annotated as Dict[str, int]
    def func(value: Dict[str, int]): pass
    codeflash_output = extract_value_type_hint(func) # 19.4μs -> 1.49μs (1199% faster)

def test_many_functions_with_various_annotations():
    # Test 100 different functions with different type annotations for 'value'
    for i in range(100):
        # Alternate between int, str, float, bool
        t = [int, str, float, bool][i % 4]
        def func(value: t): pass
        codeflash_output = extract_value_type_hint(func) # 517μs -> 31.4μs (1548% faster)

def test_large_union_with_builtin_and_custom_types():
    # Union of 500 custom types and int
    types = tuple(type(f"Custom{i}", (), {}) for i in range(500))
    union_type = Union[types + (int,)]
    def func(value: union_type): pass
    expected = " | ".join(cls.__name__ for cls in types) + " | int"
    codeflash_output = extract_value_type_hint(func) # 24.3μs -> 1.72μs (1315% 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-extract_value_type_hint-mhb3q6or and push.