⚡️ Speed up function is_primitive by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for is_primitive in nvflare/tool/job/config/config_indexer.py

⏱️ Runtime : 2.33 milliseconds → 2.07 milliseconds (best of 105 runs)

📝 Explanation and details

The optimization combines multiple isinstance() calls into a single call using a tuple of types, reducing function call overhead and improving performance by ~12%.

Key changes:

• Consolidated type checking: Instead of 4 separate isinstance() calls chained with or, the code now uses isinstance(value, _PRIMITIVE_TYPES) where _PRIMITIVE_TYPES = (int, float, str, bool) is a pre-allocated tuple constant.
• Reduced function calls: The original code made up to 4 isinstance() calls per invocation, while the optimized version makes only 1 call for primitive types.

Why this is faster:

• isinstance() with a tuple of types is optimized in CPython to check all types in a single C-level loop, avoiding Python function call overhead between checks
• The constant tuple _PRIMITIVE_TYPES is allocated once at module load time rather than being recreated implicitly in each call
• Short-circuit evaluation still occurs - if the value matches any type in the tuple, the check returns immediately

Performance characteristics:

• Best for primitive types: Shows 10-25% speedups for common primitives (float, str, bool) as seen in test results
• Excellent for non-primitives: Shows 20-40+ % speedups for complex types (tuples, dicts, custom objects) because they fail the single isinstance check faster
• Large-scale workloads: Maintains consistent 8-20% improvements across bulk operations with mixed data types

The optimization is particularly effective because isinstance() with multiple types is a well-optimized CPython operation, making this a classic Python performance pattern.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from nvflare.tool.job.config.config_indexer import is_primitive

# unit tests

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

def test_int_is_primitive():
    # Test with positive integer
    codeflash_output = is_primitive(42) # 427ns -> 419ns (1.91% faster)
    # Test with negative integer
    codeflash_output = is_primitive(-7) # 155ns -> 162ns (4.32% slower)
    # Test with zero
    codeflash_output = is_primitive(0) # 123ns -> 128ns (3.91% slower)

def test_float_is_primitive():
    # Test with positive float
    codeflash_output = is_primitive(3.14) # 394ns -> 328ns (20.1% faster)
    # Test with negative float
    codeflash_output = is_primitive(-2.718) # 201ns -> 177ns (13.6% faster)
    # Test with zero float
    codeflash_output = is_primitive(0.0) # 158ns -> 139ns (13.7% faster)

def test_str_is_primitive():
    # Test with non-empty string
    codeflash_output = is_primitive("hello") # 420ns -> 338ns (24.3% faster)
    # Test with empty string
    codeflash_output = is_primitive("") # 256ns -> 213ns (20.2% faster)

def test_bool_is_primitive():
    # Test with True
    codeflash_output = is_primitive(True) # 363ns -> 322ns (12.7% faster)
    # Test with False
    codeflash_output = is_primitive(False) # 193ns -> 176ns (9.66% faster)

def test_none_is_primitive():
    # Test with None
    codeflash_output = is_primitive(None) # 496ns -> 440ns (12.7% faster)

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

def test_complex_number_is_not_primitive():
    # Complex numbers should not be considered primitive
    codeflash_output = is_primitive(1+2j) # 440ns -> 467ns (5.78% slower)

def test_list_is_not_primitive():
    # Lists are not primitive
    codeflash_output = is_primitive([1, 2, 3]) # 480ns -> 380ns (26.3% faster)
    codeflash_output = is_primitive([]) # 298ns -> 234ns (27.4% faster)

def test_tuple_is_not_primitive():
    # Tuples are not primitive
    codeflash_output = is_primitive((1, 2)) # 696ns -> 469ns (48.4% faster)
    codeflash_output = is_primitive(()) # 320ns -> 224ns (42.9% faster)

def test_dict_is_not_primitive():
    # Dictionaries are not primitive
    codeflash_output = is_primitive({'a': 1}) # 437ns -> 359ns (21.7% faster)
    codeflash_output = is_primitive({}) # 293ns -> 219ns (33.8% faster)

def test_set_is_not_primitive():
    # Sets are not primitive
    codeflash_output = is_primitive({1, 2, 3}) # 418ns -> 326ns (28.2% faster)
    codeflash_output = is_primitive(set()) # 309ns -> 222ns (39.2% faster)

def test_bytes_and_bytearray_are_not_primitive():
    # Bytes and bytearrays are not primitive
    codeflash_output = is_primitive(b"bytes") # 430ns -> 380ns (13.2% faster)
    codeflash_output = is_primitive(bytearray([1,2,3])) # 309ns -> 267ns (15.7% faster)

def test_range_object_is_not_primitive():
    # Range objects are not primitive
    codeflash_output = is_primitive(range(10)) # 426ns -> 393ns (8.40% faster)

def test_custom_object_is_not_primitive():
    # Instances of user-defined classes are not primitive
    class Foo:
        pass
    codeflash_output = is_primitive(Foo()) # 618ns -> 536ns (15.3% faster)

def test_function_is_not_primitive():
    # Functions are not primitive
    def bar(): pass
    codeflash_output = is_primitive(bar) # 448ns -> 361ns (24.1% faster)

def test_lambda_is_not_primitive():
    # Lambdas are not primitive
    codeflash_output = is_primitive(lambda x: x) # 455ns -> 359ns (26.7% faster)



def test_frozenset_is_not_primitive():
    # frozenset is not primitive
    codeflash_output = is_primitive(frozenset([1,2,3])) # 695ns -> 490ns (41.8% faster)

def test_nan_and_inf_are_primitive():
    # float('nan') and float('inf') are floats, thus primitive
    codeflash_output = is_primitive(float('nan')) # 391ns -> 313ns (24.9% faster)
    codeflash_output = is_primitive(float('inf')) # 212ns -> 199ns (6.53% faster)
    codeflash_output = is_primitive(float('-inf')) # 155ns -> 142ns (9.15% faster)

def test_bool_vs_int_behavior():
    # bool is a subclass of int, but both should be considered primitive
    codeflash_output = is_primitive(True) # 347ns -> 347ns (0.000% faster)
    codeflash_output = is_primitive(False) # 196ns -> 186ns (5.38% faster)
    codeflash_output = is_primitive(1) # 155ns -> 163ns (4.91% slower)
    codeflash_output = is_primitive(0) # 123ns -> 125ns (1.60% slower)


def test_object_with_custom_eq():
    # Objects with __eq__ defined should not be considered primitive
    class Weird:
        def __eq__(self, other): return True
    codeflash_output = is_primitive(Weird()) # 729ns -> 725ns (0.552% faster)

def test_none_type():
    # NoneType is primitive (None is the only instance)
    codeflash_output = is_primitive(type(None)()) # 493ns -> 480ns (2.71% faster)

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

def test_large_list_of_primitives():
    # Test a large list of primitive values
    primitives = [i for i in range(1000)]  # ints
    for val in primitives:
        codeflash_output = is_primitive(val) # 122μs -> 121μs (0.858% faster)

def test_large_list_of_non_primitives():
    # Test a large list of non-primitive values
    non_primitives = [[i] for i in range(1000)]  # lists
    for val in non_primitives:
        codeflash_output = is_primitive(val) # 206μs -> 169μs (21.6% faster)

def test_mixed_large_scale():
    # Test a mixed list of primitives and non-primitives
    mixed = []
    for i in range(500):
        mixed.append(i)         # int (primitive)
        mixed.append([i, i+1])  # list (non-primitive)
        mixed.append(str(i))    # str (primitive)
        mixed.append({'a': i})  # dict (non-primitive)
    # Check correct classification
    for idx, val in enumerate(mixed):
        if idx % 4 == 0 or idx % 4 == 2:
            codeflash_output = is_primitive(val)
        else:
            codeflash_output = is_primitive(val)

def test_performance_large_scale():
    # Ensure function is performant with large primitive and non-primitive input
    import time
    primitives = [float(i) for i in range(1000)]
    non_primitives = [(i, i+1) for i in range(1000)]
    start = time.time()
    for val in primitives:
        codeflash_output = is_primitive(val) # 146μs -> 134μs (9.49% faster)
    for val in non_primitives:
        codeflash_output = is_primitive(val) # 205μs -> 169μs (21.3% faster)
    elapsed = time.time() - start
# 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 nvflare.tool.job.config.config_indexer import is_primitive

# unit tests

# 1. Basic Test Cases

def test_int_is_primitive():
    # Test with a standard integer
    codeflash_output = is_primitive(42) # 397ns -> 440ns (9.77% slower)

def test_float_is_primitive():
    # Test with a standard float
    codeflash_output = is_primitive(3.1415) # 439ns -> 396ns (10.9% faster)

def test_str_is_primitive():
    # Test with a standard string
    codeflash_output = is_primitive("hello") # 392ns -> 360ns (8.89% faster)

def test_bool_true_is_primitive():
    # Test with boolean True
    codeflash_output = is_primitive(True) # 376ns -> 364ns (3.30% faster)

def test_bool_false_is_primitive():
    # Test with boolean False
    codeflash_output = is_primitive(False) # 313ns -> 354ns (11.6% slower)

def test_none_is_primitive():
    # Test with None
    codeflash_output = is_primitive(None) # 496ns -> 470ns (5.53% faster)

# 2. Edge Test Cases

def test_empty_string_is_primitive():
    # Test with empty string
    codeflash_output = is_primitive("") # 449ns -> 410ns (9.51% faster)

def test_zero_int_is_primitive():
    # Test with zero as int
    codeflash_output = is_primitive(0) # 319ns -> 334ns (4.49% slower)

def test_zero_float_is_primitive():
    # Test with zero as float
    codeflash_output = is_primitive(0.0) # 403ns -> 362ns (11.3% faster)

def test_negative_int_is_primitive():
    # Test with negative integer
    codeflash_output = is_primitive(-100) # 321ns -> 326ns (1.53% slower)

def test_negative_float_is_primitive():
    # Test with negative float
    codeflash_output = is_primitive(-3.14) # 375ns -> 329ns (14.0% faster)

def test_large_int_is_primitive():
    # Test with very large integer
    codeflash_output = is_primitive(10**18) # 299ns -> 312ns (4.17% slower)

def test_special_float_nan_is_primitive():
    # Test with float('nan')
    codeflash_output = is_primitive(float('nan')) # 399ns -> 342ns (16.7% faster)

def test_special_float_inf_is_primitive():
    # Test with float('inf')
    codeflash_output = is_primitive(float('inf')) # 367ns -> 323ns (13.6% faster)

def test_special_float_neg_inf_is_primitive():
    # Test with float('-inf')
    codeflash_output = is_primitive(float('-inf')) # 360ns -> 350ns (2.86% faster)


def test_int_subclass_is_primitive():
    # Test with an int subclass
    class MyInt(int):
        pass
    codeflash_output = is_primitive(MyInt(5)) # 508ns -> 549ns (7.47% slower)

def test_float_subclass_is_primitive():
    # Test with a float subclass
    class MyFloat(float):
        pass
    codeflash_output = is_primitive(MyFloat(2.5)) # 644ns -> 568ns (13.4% faster)

def test_str_subclass_is_primitive():
    # Test with a str subclass
    class MyStr(str):
        pass
    codeflash_output = is_primitive(MyStr("abc")) # 737ns -> 599ns (23.0% faster)

def test_object_is_not_primitive():
    # Test with generic object
    codeflash_output = is_primitive(object()) # 501ns -> 489ns (2.45% faster)

def test_list_is_not_primitive():
    # Test with list
    codeflash_output = is_primitive([1, 2, 3]) # 419ns -> 431ns (2.78% slower)

def test_tuple_is_not_primitive():
    # Test with tuple
    codeflash_output = is_primitive((1, 2)) # 647ns -> 510ns (26.9% faster)

def test_dict_is_not_primitive():
    # Test with dict
    codeflash_output = is_primitive({"a": 1}) # 726ns -> 442ns (64.3% faster)

def test_set_is_not_primitive():
    # Test with set
    codeflash_output = is_primitive({1, 2}) # 449ns -> 429ns (4.66% faster)

def test_frozenset_is_not_primitive():
    # Test with frozenset
    codeflash_output = is_primitive(frozenset([1, 2])) # 657ns -> 574ns (14.5% faster)

def test_bytes_is_not_primitive():
    # Test with bytes
    codeflash_output = is_primitive(b"abc") # 460ns -> 392ns (17.3% faster)

def test_bytearray_is_not_primitive():
    # Test with bytearray
    codeflash_output = is_primitive(bytearray(b"abc")) # 457ns -> 382ns (19.6% faster)

def test_complex_is_not_primitive():
    # Test with complex number
    codeflash_output = is_primitive(1+2j) # 483ns -> 437ns (10.5% faster)

def test_function_is_not_primitive():
    # Test with a function object
    def foo(): pass
    codeflash_output = is_primitive(foo) # 432ns -> 381ns (13.4% faster)

def test_lambda_is_not_primitive():
    # Test with a lambda function
    codeflash_output = is_primitive(lambda x: x) # 446ns -> 369ns (20.9% faster)

def test_class_type_is_not_primitive():
    # Test with a class type
    codeflash_output = is_primitive(int) # 549ns -> 460ns (19.3% faster)

def test_module_is_not_primitive():
    # Test with a module
    import math
    codeflash_output = is_primitive(math) # 613ns -> 488ns (25.6% faster)

def test_custom_class_instance_is_not_primitive():
    # Test with a custom class instance
    class MyClass:
        pass
    codeflash_output = is_primitive(MyClass()) # 611ns -> 562ns (8.72% faster)


def test_range_is_not_primitive():
    # Test with range object
    codeflash_output = is_primitive(range(10)) # 460ns -> 417ns (10.3% faster)


def test_exception_instance_is_not_primitive():
    # Test with exception instance
    codeflash_output = is_primitive(ValueError("error")) # 509ns -> 551ns (7.62% slower)

def test_property_is_not_primitive():
    # Test with property object
    class C:
        @property
        def x(self): return 1
    codeflash_output = is_primitive(C.x) # 680ns -> 424ns (60.4% faster)

def test_none_type_is_not_primitive():
    # Test with NoneType type object (not None itself)
    codeflash_output = is_primitive(type(None)) # 540ns -> 446ns (21.1% faster)

# 3. Large Scale Test Cases

def test_large_list_of_primitives():
    # Test a large list of primitives - all should be recognized individually
    values = [None, True, False, 0, 1, -1, 3.14, -2.71, "", "a", "b"] * 90  # 990 elements
    for v in values:
        codeflash_output = is_primitive(v) # 160μs -> 148μs (7.68% faster)

def test_large_list_of_non_primitives():
    # Test a large list of non-primitives - all should be recognized individually
    values = [[1], (2,), {3}, {"a": 4}, object(), b"x", bytearray(b"x")] * 142  # 994 elements
    for v in values:
        codeflash_output = is_primitive(v) # 207μs -> 173μs (19.7% faster)

def test_mixed_large_list():
    # Test a large mixed list of primitives and non-primitives
    primitives = [None, True, 1, 2.0, "x"] * 150
    non_primitives = [[1], (2,), {3}, {"a": 4}, object()] * 150
    values = primitives + non_primitives
    # Check correct classification
    for v in primitives:
        codeflash_output = is_primitive(v) # 128μs -> 118μs (7.71% faster)
    for v in non_primitives:
        codeflash_output = is_primitive(v) # 155μs -> 129μs (19.7% faster)

def test_performance_large_scale():
    # Performance test: ensure function works efficiently for large data
    # (not a strict timing test, but ensures no crash/hang)
    values = [i for i in range(1000)] + [str(i) for i in range(1000)] + [float(i) for i in range(1000)]
    for v in values:
        codeflash_output = is_primitive(v) # 438μs -> 403μs (8.62% faster)

def test_large_scale_edge_cases():
    # Large scale test with edge-case values
    values = [float('nan'), float('inf'), float('-inf'), "", None, True, False, 0, -1, 1e308, -1e308] * 90
    for v in values:
        codeflash_output = is_primitive(v) # 157μs -> 149μs (5.59% 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-is_primitive-mhe3f9h1 and push.