⚡️ Speed up function deserialize_primitive by 43%

[codeflash-ai]

📄 43% (0.43x) speedup for deserialize_primitive in src/datadog_api_client/model_utils.py

⏱️ Runtime : 140 milliseconds → 97.9 milliseconds (best of 5 runs)

📝 Explanation and details

The optimization achieves a 43% speedup through two key changes:

1. Fast ISO date parsing for date type: The biggest performance gain comes from adding a fast path for ISO date strings (YYYY-MM-DD). Instead of always calling the expensive parse(data) function, the code first checks if the string matches the common ISO format (length 10, hyphens at positions 4 and 7), then directly constructs the date using date(year, month, day). This optimization is dramatically effective for date parsing - test results show 1500-2300% speedups for date operations, reducing parse time from ~70-90μs to ~4-5μs per call.

2. Identity checks instead of set membership: Replaced klass in {datetime, date} with klass is datetime or klass is date (and similar changes for UUID/float). This eliminates the overhead of creating sets and computing hashes for type checking. While the per-call savings are smaller (~1-2μs), this adds up significantly across thousands of calls, showing 15-35% improvements in non-date operations.

Why these optimizations work:

• The parse() function from dateutil is designed for flexible date parsing but carries significant overhead for simple ISO dates
• Set membership requires hashing and set creation, while identity comparison (is) is a simple pointer check
• Most real-world date strings in APIs follow the standard ISO format, making the fast path highly effective

The optimizations maintain identical behavior and error handling - the fast ISO date path falls back to the original parse() method for non-standard formats, ensuring full compatibility.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from datetime import date, datetime, timedelta
from uuid import UUID

# imports
import pytest  # used for our unit tests
from datadog_api_client.exceptions import ApiValueError
# function to test
from dateutil.parser import parse
from src.datadog_api_client.model_utils import deserialize_primitive

# unit tests

# ----------- BASIC TEST CASES -----------

def test_deserialize_int_from_str():
    # Basic: string to int
    codeflash_output = deserialize_primitive("123", int, ["value"]) # 2.21μs -> 2.04μs (8.44% faster)

def test_deserialize_float_from_str():
    # Basic: string to float
    codeflash_output = deserialize_primitive("123.456", float, ["value"]) # 5.25μs -> 5.39μs (2.53% slower)

def test_deserialize_str_from_str():
    # Basic: string to str
    codeflash_output = deserialize_primitive("hello", str, ["value"]) # 1.97μs -> 1.72μs (14.4% faster)

def test_deserialize_bool_from_str_true():
    # Basic: string to bool (True)
    codeflash_output = deserialize_primitive("True", bool, ["value"]) # 2.16μs -> 1.84μs (17.1% faster)

def test_deserialize_bool_from_str_false():
    # Basic: string to bool (False)
    codeflash_output = deserialize_primitive("False", bool, ["value"]) # 2.05μs -> 1.89μs (8.46% faster)

def test_deserialize_date_from_str():
    # Basic: string to date
    codeflash_output = deserialize_primitive("2024-06-01", date, ["date"]) # 76.6μs -> 4.73μs (1519% faster)

def test_deserialize_datetime_from_str():
    # Basic: string to datetime
    codeflash_output = deserialize_primitive("2024-06-01T12:34:56", datetime, ["dt"]); dt = codeflash_output # 107μs -> 112μs (4.21% slower)

def test_deserialize_uuid_from_str():
    # Basic: string to UUID
    uuid_str = "12345678-1234-5678-1234-567812345678"
    codeflash_output = deserialize_primitive(uuid_str, UUID, ["uuid"]) # 12.6μs -> 9.56μs (31.7% faster)

def test_deserialize_int_from_int():
    # Basic: int to int
    codeflash_output = deserialize_primitive(42, int, ["int"]) # 2.05μs -> 1.69μs (20.9% faster)

def test_deserialize_float_from_float():
    # Basic: float to float
    codeflash_output = deserialize_primitive(3.14, float, ["float"]) # 2.00μs -> 2.26μs (11.3% slower)

def test_deserialize_bool_from_bool():
    # Basic: bool to bool
    codeflash_output = deserialize_primitive(True, bool, ["bool"]) # 2.15μs -> 1.73μs (24.6% faster)

def test_deserialize_str_from_int():
    # Basic: int to str
    codeflash_output = deserialize_primitive(123, str, ["str"]) # 2.05μs -> 1.74μs (18.0% faster)

def test_deserialize_str_from_float():
    # Basic: float to str
    codeflash_output = deserialize_primitive(3.14, str, ["str"]) # 4.10μs -> 4.05μs (1.04% faster)

# ----------- EDGE TEST CASES -----------

def test_deserialize_invalid_int_from_str():
    # Edge: invalid int string
    with pytest.raises(ApiValueError):
        deserialize_primitive("abc", int, ["value"]) # 15.7μs -> 14.6μs (8.00% faster)

def test_deserialize_invalid_float_from_str():
    # Edge: invalid float string
    with pytest.raises(ApiValueError):
        deserialize_primitive("abc", float, ["value"]) # 15.5μs -> 14.0μs (10.6% faster)

def test_deserialize_float_from_int_str():
    # Edge: int string to float should fail ('7' != '7.0')
    with pytest.raises(ApiValueError):
        deserialize_primitive("7", float, ["value"]) # 14.4μs -> 16.5μs (13.0% slower)


def test_deserialize_invalid_date_from_str():
    # Edge: invalid date string
    with pytest.raises(ApiValueError):
        deserialize_primitive("notadate", date, ["date"]) # 51.1μs -> 55.7μs (8.34% slower)

def test_deserialize_invalid_datetime_from_str():
    # Edge: invalid datetime string
    with pytest.raises(ApiValueError):
        deserialize_primitive("notadatetime", datetime, ["dt"]) # 65.2μs -> 57.3μs (13.9% faster)

def test_deserialize_date_from_short_str():
    # Edge: too short for date
    with pytest.raises(ApiValueError):
        deserialize_primitive("2024", date, ["date"]) # 12.4μs -> 12.8μs (3.09% slower)

def test_deserialize_datetime_from_short_str():
    # Edge: too short for datetime
    with pytest.raises(ApiValueError):
        deserialize_primitive("2024", datetime, ["dt"]) # 12.4μs -> 14.3μs (13.4% slower)

def test_deserialize_datetime_from_date_str():
    # Edge: date string to datetime should fail
    with pytest.raises(ApiValueError):
        deserialize_primitive("2024-06-01", datetime, ["dt"]) # 76.8μs -> 93.7μs (18.1% slower)

def test_deserialize_uuid_from_invalid_str():
    # Edge: invalid UUID string
    with pytest.raises(ApiValueError):
        deserialize_primitive("notauuid", UUID, ["uuid"]) # 16.0μs -> 19.8μs (19.3% slower)

def test_deserialize_float_overflow():
    # Edge: float overflow
    big_num = "1e10000"
    with pytest.raises(ApiValueError):
        deserialize_primitive(big_num, float, ["value"]) # 17.5μs -> 14.0μs (25.2% faster)

def test_deserialize_date_with_time_should_work():
    # Edge: date with time string should parse only date part
    codeflash_output = deserialize_primitive("2024-06-01T12:34:56", date, ["date"]); result = codeflash_output # 116μs -> 119μs (2.85% slower)

def test_deserialize_datetime_with_timezone():
    # Edge: datetime with timezone
    codeflash_output = deserialize_primitive("2024-06-01T12:34:56+02:00", datetime, ["dt"]); dt = codeflash_output # 144μs -> 123μs (16.8% faster)

def test_deserialize_uuid_from_uppercase_str():
    # Edge: UUID string uppercase
    uuid_str = "12345678-1234-5678-1234-567812345678".upper()
    codeflash_output = deserialize_primitive(uuid_str, UUID, ["uuid"]) # 11.8μs -> 9.31μs (26.3% faster)

def test_deserialize_bool_from_int_str_one():
    # Edge: bool from "1" string
    codeflash_output = deserialize_primitive("1", bool, ["bool"]) # 2.16μs -> 1.89μs (14.2% faster)

def test_deserialize_bool_from_int_str_zero():
    # Edge: bool from "0" string
    codeflash_output = deserialize_primitive("0", bool, ["bool"]) # 2.04μs -> 1.69μs (20.7% faster)

def test_deserialize_bool_from_int():
    # Edge: bool from int
    codeflash_output = deserialize_primitive(1, bool, ["bool"]) # 1.98μs -> 1.74μs (14.0% faster)
    codeflash_output = deserialize_primitive(0, bool, ["bool"]) # 893ns -> 649ns (37.6% faster)


def test_deserialize_date_leap_year():
    # Edge: leap year date
    codeflash_output = deserialize_primitive("2020-02-29", date, ["date"]) # 70.7μs -> 4.36μs (1521% faster)

def test_deserialize_datetime_leap_second():
    # Edge: datetime with leap second (handled as 23:59:60)
    # Note: Python's datetime does not support 60 seconds, so should fail.
    with pytest.raises(ApiValueError):
        deserialize_primitive("2016-12-31T23:59:60", datetime, ["dt"]) # 98.2μs -> 114μs (14.3% slower)

def test_deserialize_empty_string_to_int():
    # Edge: empty string to int
    with pytest.raises(ApiValueError):
        deserialize_primitive("", int, ["value"]) # 19.1μs -> 15.5μs (23.5% faster)

def test_deserialize_empty_string_to_float():
    # Edge: empty string to float
    with pytest.raises(ApiValueError):
        deserialize_primitive("", float, ["value"]) # 14.0μs -> 12.7μs (9.88% faster)


def test_deserialize_empty_string_to_date():
    # Edge: empty string to date
    with pytest.raises(ApiValueError):
        deserialize_primitive("", date, ["date"]) # 12.1μs -> 16.1μs (24.7% slower)

def test_deserialize_empty_string_to_datetime():
    # Edge: empty string to datetime
    with pytest.raises(ApiValueError):
        deserialize_primitive("", datetime, ["dt"]) # 15.2μs -> 12.0μs (27.2% faster)

def test_deserialize_empty_string_to_uuid():
    # Edge: empty string to UUID
    with pytest.raises(ApiValueError):
        deserialize_primitive("", UUID, ["uuid"]) # 16.6μs -> 16.9μs (1.37% slower)

def test_deserialize_none_to_int():
    # Edge: None to int
    with pytest.raises(TypeError):
        deserialize_primitive(None, int, ["value"]) # 5.57μs -> 5.26μs (6.01% faster)

def test_deserialize_none_to_float():
    # Edge: None to float
    with pytest.raises(TypeError):
        deserialize_primitive(None, float, ["value"]) # 5.88μs -> 5.34μs (10.0% faster)


def test_deserialize_none_to_date():
    # Edge: None to date
    with pytest.raises(TypeError):
        deserialize_primitive(None, date, ["date"]) # 4.55μs -> 4.14μs (9.91% faster)

def test_deserialize_none_to_datetime():
    # Edge: None to datetime
    with pytest.raises(TypeError):
        deserialize_primitive(None, datetime, ["dt"]) # 4.00μs -> 3.95μs (1.11% faster)

def test_deserialize_none_to_uuid():
    # Edge: None to UUID
    with pytest.raises(TypeError):
        deserialize_primitive(None, UUID, ["uuid"]) # 6.64μs -> 6.78μs (2.05% slower)

def test_deserialize_bool_from_str_case_insensitive():
    # Edge: bool from case-insensitive string
    codeflash_output = deserialize_primitive("true", bool, ["bool"]) # 2.09μs -> 1.65μs (27.0% faster)
    codeflash_output = deserialize_primitive("false", bool, ["bool"]) # 713ns -> 623ns (14.4% faster)

def test_deserialize_bool_from_str_mixed_case():
    # Edge: bool from mixed-case string
    codeflash_output = deserialize_primitive("TrUe", bool, ["bool"]) # 2.52μs -> 1.74μs (44.9% faster)
    codeflash_output = deserialize_primitive("FaLsE", bool, ["bool"]) # 782ns -> 623ns (25.5% faster)

def test_deserialize_int_from_float_str_should_fail():
    # Edge: float string to int should fail
    with pytest.raises(ApiValueError):
        deserialize_primitive("3.14", int, ["value"]) # 17.4μs -> 20.1μs (13.6% slower)


def test_deserialize_str_from_bool():
    # Edge: bool to str
    codeflash_output = deserialize_primitive(True, str, ["str"]) # 2.06μs -> 1.83μs (12.3% faster)
    codeflash_output = deserialize_primitive(False, str, ["str"]) # 751ns -> 672ns (11.8% faster)

# ----------- LARGE SCALE TEST CASES -----------

def test_large_scale_ints():
    # Large scale: 1000 ints
    for i in range(1000):
        codeflash_output = deserialize_primitive(str(i), int, ["value"]) # 547μs -> 420μs (30.4% faster)

def test_large_scale_floats():
    # Large scale: 1000 floats
    for i in range(1000):
        val = f"{i}.{i}"
        codeflash_output = deserialize_primitive(val, float, ["value"])

def test_large_scale_dates():
    # Large scale: 366 dates (leap year)
    for day in range(1, 367):  # 2020 is a leap year
        d = date(2020, 1, 1) + timedelta(days=day - 1)
        d_str = d.isoformat()
        codeflash_output = deserialize_primitive(d_str, date, ["date"]) # 10.6ms -> 439μs (2300% faster)

def test_large_scale_datetimes():
    # Large scale: 1000 datetimes
    base_dt = datetime(2024, 6, 1, 0, 0, 0)
    for i in range(1000):
        dt = base_dt + timedelta(seconds=i)
        dt_str = dt.isoformat()
        codeflash_output = deserialize_primitive(dt_str, datetime, ["dt"]); result = codeflash_output # 44.7ms -> 44.2ms (1.19% faster)

def test_large_scale_uuids():
    # Large scale: 1000 UUIDs
    for i in range(1000):
        uuid_str = f"{i:08x}-1234-5678-1234-567812345678"
        codeflash_output = deserialize_primitive(uuid_str, UUID, ["uuid"]) # 3.40ms -> 1.76ms (93.4% faster)

def test_large_scale_bools():
    # Large scale: 1000 bools alternating
    for i in range(1000):
        val = "True" if i % 2 == 0 else "False"
        codeflash_output = deserialize_primitive(val, bool, ["bool"]) # 465μs -> 350μs (32.7% faster)

def test_large_scale_strs():
    # Large scale: 1000 strings
    for i in range(1000):
        s = f"string_{i}"
        codeflash_output = deserialize_primitive(s, str, ["str"]) # 465μs -> 342μs (35.9% faster)

def test_large_scale_int_to_str():
    # Large scale: int to str
    for i in range(1000):
        codeflash_output = deserialize_primitive(i, str, ["str"]) # 552μs -> 477μs (15.6% faster)

def test_large_scale_float_to_str():
    # Large scale: float to str
    for i in range(1000):
        val = float(i) + 0.5
        codeflash_output = deserialize_primitive(val, str, ["str"]) # 785μs -> 715μs (9.78% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from datetime import date, datetime
from uuid import UUID

# imports
import pytest  # used for our unit tests
from datadog_api_client.exceptions import ApiValueError
from dateutil.parser import parse
from src.datadog_api_client.model_utils import deserialize_primitive

# unit tests

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

def test_deserialize_int_from_str():
    # Normal integer string
    codeflash_output = deserialize_primitive("42", int, ["value"]) # 2.27μs -> 1.91μs (19.2% faster)

def test_deserialize_float_from_str():
    # Normal float string
    codeflash_output = deserialize_primitive("3.14", float, ["value"]) # 4.92μs -> 4.84μs (1.67% faster)

def test_deserialize_str():
    # String to string
    codeflash_output = deserialize_primitive("hello", str, ["value"]) # 2.59μs -> 1.78μs (45.4% faster)

def test_deserialize_bool_true():
    # String "True" to bool
    codeflash_output = deserialize_primitive("True", bool, ["value"]) # 2.10μs -> 1.78μs (18.0% faster)

def test_deserialize_bool_false():
    # String "False" to bool
    codeflash_output = deserialize_primitive("False", bool, ["value"]) # 2.18μs -> 1.80μs (20.7% faster)

def test_deserialize_date():
    # ISO date string to date
    codeflash_output = deserialize_primitive("2023-06-01", date, ["value"]) # 88.1μs -> 4.81μs (1732% faster)

def test_deserialize_datetime():
    # ISO datetime string to datetime
    codeflash_output = deserialize_primitive("2023-06-01T12:34:56", datetime, ["value"]); dt = codeflash_output # 118μs -> 115μs (2.36% faster)

def test_deserialize_uuid():
    # Valid UUID string to UUID
    uuid_str = "12345678-1234-5678-1234-567812345678"
    codeflash_output = deserialize_primitive(uuid_str, UUID, ["value"]) # 13.3μs -> 9.55μs (38.9% faster)

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

def test_deserialize_int_invalid():
    # Invalid integer string
    with pytest.raises(ApiValueError):
        deserialize_primitive("not_an_int", int, ["value"]) # 18.6μs -> 15.3μs (21.3% faster)

def test_deserialize_float_invalid():
    # Invalid float string
    with pytest.raises(ApiValueError):
        deserialize_primitive("not_a_float", float, ["value"]) # 13.6μs -> 14.8μs (7.94% slower)

def test_deserialize_float_int_string():
    # Should raise: '7' is not a float, even though float('7') works
    with pytest.raises(ApiValueError):
        deserialize_primitive("7", float, ["value"]) # 17.7μs -> 16.2μs (9.46% faster)


def test_deserialize_datetime_invalid_format():
    # Invalid datetime format
    with pytest.raises(ApiValueError):
        deserialize_primitive("2023-06-01", datetime, ["value"]) # 103μs -> 95.6μs (8.37% faster)

def test_deserialize_datetime_too_short():
    # Too short to be a datetime
    with pytest.raises(ApiValueError):
        deserialize_primitive("2023", datetime, ["value"]) # 14.3μs -> 12.7μs (12.4% faster)

def test_deserialize_date_too_short():
    # Too short to be a date
    with pytest.raises(ApiValueError):
        deserialize_primitive("2023", date, ["value"]) # 15.0μs -> 12.6μs (19.6% faster)

def test_deserialize_uuid_invalid():
    # Invalid UUID string
    with pytest.raises(ApiValueError):
        deserialize_primitive("not_a_uuid", UUID, ["value"]) # 19.9μs -> 19.3μs (3.28% faster)

def test_deserialize_bool_case_insensitive():
    # Should convert "true"/"false" case-insensitively
    codeflash_output = deserialize_primitive("true", bool, ["value"]) # 2.24μs -> 1.98μs (13.3% faster)
    codeflash_output = deserialize_primitive("false", bool, ["value"]) # 792ns -> 615ns (28.8% faster)

def test_deserialize_bool_numeric():
    # Should convert "1"/"0" to True/False
    codeflash_output = deserialize_primitive("1", bool, ["value"]) # 2.09μs -> 1.88μs (11.1% faster)
    codeflash_output = deserialize_primitive("0", bool, ["value"]) # 796ns -> 561ns (41.9% faster)

def test_deserialize_float_with_leading_zero():
    # Float with leading zero
    codeflash_output = deserialize_primitive("0.123", float, ["value"]) # 5.75μs -> 5.29μs (8.54% faster)


def test_deserialize_float_with_exponent_mismatch():
    # Should raise: '1e3' -> 1000.0 -> '1000.0' != '1e3'
    with pytest.raises(ApiValueError):
        deserialize_primitive("1e3", float, ["value"]) # 18.7μs -> 13.8μs (34.9% faster)


def test_deserialize_datetime_with_timezone():
    # Datetime with timezone
    codeflash_output = deserialize_primitive("2023-06-01T12:34:56+00:00", datetime, ["value"]); dt = codeflash_output # 134μs -> 141μs (5.04% slower)

def test_deserialize_date_with_timezone_should_fail():
    # Date with timezone should fail for date
    with pytest.raises(ApiValueError):
        deserialize_primitive("2023-06-01+00:00", date, ["value"]) # 93.4μs -> 83.6μs (11.7% faster)

def test_deserialize_uuid_uppercase():
    # UUID string in uppercase
    uuid_str = "12345678-1234-5678-1234-567812345678".upper()
    codeflash_output = deserialize_primitive(uuid_str, UUID, ["value"]) # 12.7μs -> 9.00μs (40.7% faster)

def test_deserialize_int_from_int():
    # Passing integer directly
    codeflash_output = deserialize_primitive(123, int, ["value"]) # 1.96μs -> 1.87μs (4.59% faster)

def test_deserialize_float_from_float():
    # Passing float directly
    codeflash_output = deserialize_primitive(3.14, float, ["value"]) # 2.43μs -> 2.26μs (7.48% faster)

def test_deserialize_str_from_int():
    # Passing int to str
    codeflash_output = deserialize_primitive(123, str, ["value"]) # 2.12μs -> 2.01μs (5.42% faster)

def test_deserialize_bool_from_bool():
    # Passing bool directly
    codeflash_output = deserialize_primitive(True, bool, ["value"]) # 2.77μs -> 1.79μs (55.0% faster)



def test_large_scale_int_deserialization():
    # Large list of integer strings
    for i in range(1000):
        s = str(i)
        codeflash_output = deserialize_primitive(s, int, ["value"]) # 558μs -> 418μs (33.4% faster)

def test_large_scale_float_deserialization():
    # Large list of float strings
    for i in range(1000):
        s = f"{i}.0"
        codeflash_output = deserialize_primitive(s, float, ["value"]) # 743μs -> 644μs (15.4% faster)

def test_large_scale_uuid_deserialization():
    # Large list of UUID strings
    for i in range(1000):
        uuid_str = f"{i:08x}-1234-5678-1234-567812345678"
        codeflash_output = deserialize_primitive(uuid_str, UUID, ["value"]) # 3.34ms -> 1.76ms (90.1% faster)

def test_large_scale_date_deserialization():
    # Large list of date strings (incrementing days)
    for i in range(1, 1001):
        day = (i % 28) + 1  # to avoid invalid dates
        date_str = f"2023-06-{day:02d}"
        codeflash_output = deserialize_primitive(date_str, date, ["value"]) # 28.1ms -> 1.17ms (2300% faster)

def test_large_scale_datetime_deserialization():
    # Large list of datetime strings (incrementing seconds)
    for i in range(1000):
        hour = (i // 60) % 24
        minute = i % 60
        second = i % 60
        dt_str = f"2023-06-01T{hour:02d}:{minute:02d}:{second:02d}"
        codeflash_output = deserialize_primitive(dt_str, datetime, ["value"]); dt = codeflash_output # 44.2ms -> 43.6ms (1.23% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

To edit these changes git checkout codeflash/optimize-deserialize_primitive-mgcuvnkz and push.