⚡️ Speed up function convert_date_to_datetime by 41%

[codeflash-ai]

📄 41% (0.41x) speedup for convert_date_to_datetime in src/bokeh/util/serialization.py

⏱️ Runtime : 4.38 milliseconds → 3.11 milliseconds (best of 133 runs)

📝 Explanation and details

The optimized version achieves a 40% speedup by eliminating the expensive timetuple() call and slice operation from the original implementation.

Key optimization:

• Original approach: dt.datetime(*obj.timetuple()[:6], tzinfo=dt.timezone.utc) creates a full struct_time tuple (9 elements), slices it to get the first 6 elements, then unpacks them into the datetime constructor.
• Optimized approach: Directly accesses obj.year, obj.month, obj.day attributes and constructs the datetime with only the needed components.

Why this is faster:
The timetuple() method performs unnecessary work by computing all time components (including hour, minute, second, weekday, yearday, dst flag) when only year/month/day are needed. The slice operation [:6] and tuple unpacking * add additional overhead.

Additional improvement:
Added an isinstance(obj, dt.datetime) check to handle datetime objects more efficiently by using replace(tzinfo=dt.timezone.utc) instead of reconstructing them entirely.

Performance characteristics:

• Most effective on basic date conversion operations (32-48% speedup in test cases)
• Maintains consistent ~40% improvement across large-scale operations (1000+ dates)
• Small overhead (~10-25% slower) for error cases due to the added type check, but these are exceptional paths
• Particularly beneficial for sequential date processing workflows

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
unit/bokeh/core/property/test_datetime.py::Test_Datetime.test_transform_date	2.28μs	1.66μs	37.0%✅
unit/bokeh/core/property/test_datetime.py::Test_Datetime.test_transform_str	2.70μs	2.58μs	4.45%✅
unit/bokeh/models/widgets/test_slider.py::TestDateRangeSlider.test_value_as_date_when_set_as_timestamp	7.42μs	4.71μs	57.6%✅
unit/bokeh/models/widgets/test_slider.py::TestDateRangeSlider.test_value_as_date_when_set_mixed	5.61μs	4.82μs	16.6%✅
unit/bokeh/models/widgets/test_slider.py::TestDateSlider.test_value_and_value_throttled	3.83μs	3.91μs	-2.22%⚠️
unit/bokeh/models/widgets/test_slider.py::TestDateSlider.test_value_as_date_when_set_as_timestamp	4.08μs	3.24μs	25.9%✅

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import datetime as dt
from typing import Any

# imports
import pytest  # used for our unit tests
from bokeh.util.serialization import convert_date_to_datetime

DT_EPOCH = dt.datetime.fromtimestamp(0, tz=dt.timezone.utc)
from bokeh.util.serialization import convert_date_to_datetime

#-----------------------------------------------------------------------------
# Code
#-----------------------------------------------------------------------------

# unit tests

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

def test_basic_today():
    # Test conversion of today's date
    today = dt.date.today()
    codeflash_output = convert_date_to_datetime(today); result = codeflash_output # 3.60μs -> 3.20μs (12.7% faster)
    # Should be equal to the timestamp for today at midnight UTC
    expected = (dt.datetime(today.year, today.month, today.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_specific_date():
    # Test a specific known date
    d = dt.date(2020, 1, 1)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.60μs -> 2.69μs (34.1% faster)
    expected = (dt.datetime(2020, 1, 1, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_leap_year():
    # Test a leap day
    d = dt.date(2016, 2, 29)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.51μs -> 2.65μs (32.5% faster)
    expected = (dt.datetime(2016, 2, 29, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_new_years_eve():
    # Test December 31st
    d = dt.date(1999, 12, 31)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.41μs -> 2.36μs (44.1% faster)
    expected = (dt.datetime(1999, 12, 31, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_epoch():
    # Test the Unix epoch date
    d = dt.date(1970, 1, 1)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.35μs -> 2.50μs (33.7% faster)
    expected = 0.0

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

def test_edge_min_date():
    # Test the minimum representable date
    d = dt.date.min
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.92μs -> 2.94μs (33.2% faster)
    expected = (dt.datetime(dt.date.min.year, dt.date.min.month, dt.date.min.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_max_date():
    # Test the maximum representable date
    d = dt.date.max
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.69μs -> 2.60μs (41.9% faster)
    expected = (dt.datetime(dt.date.max.year, dt.date.max.month, dt.date.max.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000


def test_edge_type_error_on_string():
    # Test passing a string (should raise AttributeError)
    with pytest.raises(AttributeError):
        convert_date_to_datetime("2020-01-01") # 1.55μs -> 1.84μs (15.5% slower)

def test_edge_type_error_on_int():
    # Test passing an integer (should raise AttributeError)
    with pytest.raises(AttributeError):
        convert_date_to_datetime(20200101) # 1.28μs -> 1.41μs (9.36% slower)

def test_edge_type_error_on_none():
    # Test passing None (should raise AttributeError)
    with pytest.raises(AttributeError):
        convert_date_to_datetime(None) # 1.15μs -> 1.53μs (24.9% slower)

def test_edge_type_error_on_object():
    # Test passing an unrelated object (should raise AttributeError)
    class Dummy:
        pass
    with pytest.raises(AttributeError):
        convert_date_to_datetime(Dummy()) # 1.25μs -> 1.63μs (23.4% slower)

def test_edge_date_with_time_subclass():
    # Test a subclass of date that adds a time attribute
    class MyDate(dt.date):
        def __init__(self, *args, **kwargs):
            super().__init__()
            self.time = dt.time(12, 34, 56)
    mydate = dt.date(2022, 3, 4)
    codeflash_output = convert_date_to_datetime(mydate); result = codeflash_output # 7.32μs -> 4.75μs (54.3% faster)
    expected = (dt.datetime(2022, 3, 4, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_dst_transition():
    # Test a date during a DST transition (should not matter, always UTC midnight)
    # For example, in US, DST starts on 2021-03-14
    d = dt.date(2021, 3, 14)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 4.27μs -> 2.67μs (60.3% faster)
    expected = (dt.datetime(2021, 3, 14, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_leap_century():
    # Test Feb 29 on a leap century year (2000 is leap, 1900 is not)
    d = dt.date(2000, 2, 29)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.79μs -> 2.44μs (55.3% faster)
    expected = (dt.datetime(2000, 2, 29, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

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

def test_large_scale_sequential_dates():
    # Test a sequence of 1000 consecutive dates
    start = dt.date(2000, 1, 1)
    for i in range(1000):
        d = start + dt.timedelta(days=i)
        codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 1.01ms -> 718μs (41.0% faster)
        expected = (dt.datetime(d.year, d.month, d.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_large_scale_random_dates():
    # Test 100 random dates between 1970 and 2100
    import random
    for _ in range(100):
        year = random.randint(1970, 2100)
        month = random.randint(1, 12)
        # Handle months with fewer than 31 days
        if month == 2:
            if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
                day = random.randint(1, 29)
            else:
                day = random.randint(1, 28)
        elif month in [4, 6, 9, 11]:
            day = random.randint(1, 30)
        else:
            day = random.randint(1, 31)
        d = dt.date(year, month, day)
        codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 112μs -> 79.1μs (42.4% faster)
        expected = (dt.datetime(year, month, day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000



#------------------------------------------------
from __future__ import annotations

import datetime as dt  # used for creating date and datetime objects
import math  # used for checking float equality with nan/inf
from typing import Any

# imports
import pytest  # used for our unit tests
from bokeh.util.serialization import convert_date_to_datetime

DT_EPOCH = dt.datetime.fromtimestamp(0, tz=dt.timezone.utc)
from bokeh.util.serialization import convert_date_to_datetime

#-----------------------------------------------------------------------------
# Code
#-----------------------------------------------------------------------------

# unit tests

# ---------------------------
# 1. Basic Test Cases
# ---------------------------

def test_basic_today():
    # Test conversion of today's date
    today = dt.date.today()
    codeflash_output = convert_date_to_datetime(today); result = codeflash_output # 4.17μs -> 3.14μs (32.7% faster)
    expected = (dt.datetime(today.year, today.month, today.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_specific_date():
    # Test conversion of a specific date
    d = dt.date(2020, 1, 1)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.79μs -> 2.80μs (35.2% faster)
    expected = (dt.datetime(2020, 1, 1, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_epoch_date():
    # Test conversion of the Unix epoch date (1970-01-01)
    d = dt.date(1970, 1, 1)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.64μs -> 2.63μs (38.4% faster)
    expected = 0.0

def test_basic_leap_year():
    # Test conversion of a leap year date (Feb 29, 2016)
    d = dt.date(2016, 2, 29)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.63μs -> 2.58μs (40.7% faster)
    expected = (dt.datetime(2016, 2, 29, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_basic_end_of_year():
    # Test conversion of end of year date
    d = dt.date(2023, 12, 31)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.58μs -> 2.41μs (48.2% faster)
    expected = (dt.datetime(2023, 12, 31, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

# ---------------------------
# 2. Edge Test Cases
# ---------------------------

def test_edge_min_date():
    # Test conversion of the minimum possible date
    d = dt.date.min
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.81μs -> 3.02μs (26.1% faster)
    expected = (dt.datetime(dt.date.min.year, dt.date.min.month, dt.date.min.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_max_date():
    # Test conversion of the maximum possible date
    d = dt.date.max
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.53μs -> 2.52μs (40.5% faster)
    expected = (dt.datetime(dt.date.max.year, dt.date.max.month, dt.date.max.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_dst_transition():
    # Test conversion of a date during DST transition (shouldn't affect date, but good to check)
    # DST transition in US: 2023-03-12
    d = dt.date(2023, 3, 12)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.32μs -> 2.28μs (45.6% faster)
    expected = (dt.datetime(2023, 3, 12, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_leap_century():
    # Test conversion of a leap century date (year 2000 is a leap year)
    d = dt.date(2000, 2, 29)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.40μs -> 2.31μs (47.1% faster)
    expected = (dt.datetime(2000, 2, 29, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_non_leap_century():
    # Test conversion of a non-leap century date (year 1900 is not a leap year)
    d = dt.date(1900, 2, 28)
    codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 3.59μs -> 2.48μs (44.9% faster)
    expected = (dt.datetime(1900, 2, 28, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_edge_invalid_type():
    # Test passing an invalid type (should raise AttributeError)
    with pytest.raises(AttributeError):
        convert_date_to_datetime("2020-01-01") # 1.22μs -> 1.50μs (18.2% slower)


def test_edge_none():
    # Test passing None (should raise AttributeError)
    with pytest.raises(AttributeError):
        convert_date_to_datetime(None) # 1.58μs -> 1.94μs (18.4% slower)

def test_edge_float_inf_nan():
    # Test passing float('inf') or float('nan') (should raise AttributeError)
    with pytest.raises(AttributeError):
        convert_date_to_datetime(float('inf')) # 1.35μs -> 1.46μs (7.13% slower)
    with pytest.raises(AttributeError):
        convert_date_to_datetime(float('nan')) # 585ns -> 709ns (17.5% slower)

def test_edge_negative_year():
    # Python's datetime does not support negative years, so this should raise ValueError
    with pytest.raises(ValueError):
        d = dt.date(-1, 1, 1)
        convert_date_to_datetime(d)

# ---------------------------
# 3. Large Scale Test Cases
# ---------------------------

def test_large_scale_sequential_dates():
    # Test conversion of 1000 sequential dates
    start_date = dt.date(2000, 1, 1)
    for i in range(1000):
        d = start_date + dt.timedelta(days=i)
        codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 1.02ms -> 720μs (41.9% faster)
        expected = (dt.datetime(d.year, d.month, d.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000

def test_large_scale_random_dates():
    # Test conversion of 1000 random dates between 1970-01-01 and 2100-12-31
    import random
    random.seed(42)  # deterministic
    for _ in range(1000):
        year = random.randint(1970, 2100)
        month = random.randint(1, 12)
        # Handle days per month, including leap years
        if month == 2:
            if (year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)):
                day = random.randint(1, 29)
            else:
                day = random.randint(1, 28)
        elif month in [4, 6, 9, 11]:
            day = random.randint(1, 30)
        else:
            day = random.randint(1, 31)
        d = dt.date(year, month, day)
        codeflash_output = convert_date_to_datetime(d); result = codeflash_output # 1.06ms -> 748μs (42.1% faster)
        expected = (dt.datetime(d.year, d.month, d.day, tzinfo=dt.timezone.utc) - DT_EPOCH).total_seconds() * 1000



#------------------------------------------------
from bokeh.util.serialization import convert_date_to_datetime

def test_convert_date_to_datetime():
    convert_date_to_datetime(datetime.date(1, 2, 1))

To edit these changes git checkout codeflash/optimize-convert_date_to_datetime-mhb2v3xk and push.