⚡️ Speed up function `deserialize_primitive` by 43% by codeflash-ai[bot] · Pull Request #19 · aseembits93/datadog-api-client-python

codeflash-ai · 2025-10-04T22:39:52Z

📄 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.

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.

codeflash-ai bot requested a review from aseembits93 October 4, 2025 22:39

codeflash-ai bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label Oct 4, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

⚡️ Speed up function `deserialize_primitive` by 43%#19

⚡️ Speed up function `deserialize_primitive` by 43%#19
codeflash-ai[bot] wants to merge 1 commit intomasterfrom
codeflash/optimize-deserialize_primitive-mgcuvnkz

codeflash-ai bot commented Oct 4, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

Conversation

codeflash-ai bot commented Oct 4, 2025

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

📝 Explanation and details

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

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